👤


CentOS 7.0 - man page for cmakevars (centos section 1)

Linux & Unix Commands - Search Man Pages

Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)


cmakevars(1)									     cmakevars(1)

NAME
       cmakevars - Reference of CMake variables.

VARIABLES THAT PROVIDE INFORMATION
       variables defined by cmake, that give information about the project, and cmake

       CMAKE_AR
	      Name of archiving tool for static libraries.

	      This specifies name of the program that creates archive or static libraries.

       CMAKE_ARGC
	      Number of command line arguments passed to CMake in script mode.

	      When  run in -P script mode, CMake sets this variable to the number of command line
	      arguments. See also CMAKE_ARGV0, 1, 2 ...

       CMAKE_ARGV0
	      Command line argument passed to CMake in script mode.

	      When run in -P script mode, CMake sets this variable  to	the  first  command  line
	      argument. It then also sets CMAKE_ARGV1, CMAKE_ARGV2, ... and so on, up to the num-
	      ber of command line arguments given. See also CMAKE_ARGC.

       CMAKE_BINARY_DIR
	      The path to the top level of the build tree.

	      This is the full path to the top level of the current  CMake  build  tree.  For  an
	      in-source build, this would be the same as CMAKE_SOURCE_DIR.

       CMAKE_BUILD_TOOL
	      Tool used for the actual build process.

	      This  variable  is  set  to  the program that will be needed to build the output of
	      CMake.   If the generator selected was Visual Studio 6, the  CMAKE_BUILD_TOOL  will
	      be set to msdev, for Unix makefiles it will be set to make or gmake, and for Visual
	      Studio 7 it set to devenv.  For Nmake Makefiles the value is  nmake.  This  can  be
	      useful for adding special flags and commands based on the final build environment.

       CMAKE_CACHEFILE_DIR
	      The directory with the CMakeCache.txt file.

	      This  is	the  full  path  to the directory that has the CMakeCache.txt file in it.
	      This is the same as CMAKE_BINARY_DIR.

       CMAKE_CACHE_MAJOR_VERSION
	      Major version of CMake used to create the CMakeCache.txt file

	      This is stores the major version of CMake used to write a CMake cache file.  It  is
	      only  different  when  a	different version of CMake is run on a previously created
	      cache file.

       CMAKE_CACHE_MINOR_VERSION
	      Minor version of CMake used to create the CMakeCache.txt file

	      This is stores the minor version of CMake used to write a CMake cache file.  It  is
	      only  different  when  a	different version of CMake is run on a previously created
	      cache file.

       CMAKE_CACHE_PATCH_VERSION
	      Patch version of CMake used to create the CMakeCache.txt file

	      This is stores the patch version of CMake used to write a CMake cache file.  It  is
	      only  different  when  a	different version of CMake is run on a previously created
	      cache file.

       CMAKE_CFG_INTDIR
	      Build-time reference to per-configuration output subdirectory.

	      For native build systems supporting multiple configurations in the build tree (such
	      as  Visual  Studio  and  Xcode),	the value is a reference to a build-time variable
	      specifying the name of the per-configuration output subdirectory.  On Makefile gen-
	      erators  this  evaluates	to "." because there is only one configuration in a build
	      tree.  Example values:

		$(IntDir)	 = Visual Studio 6
		$(OutDir)	 = Visual Studio 7, 8, 9
		$(Configuration) = Visual Studio 10
		$(CONFIGURATION) = Xcode
		.		 = Make-based tools

	      Since these values are evaluated by the native build system, this variable is suit-
	      able  only  for use in command lines that will be evaluated at build time.  Example
	      of intended usage:

		add_executable(mytool mytool.c)
		add_custom_command(
		  OUTPUT out.txt
		  COMMAND ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/mytool
			  ${CMAKE_CURRENT_SOURCE_DIR}/in.txt out.txt
		  DEPENDS mytool in.txt
		  )
		add_custom_target(drive ALL DEPENDS out.txt)

	      Note that CMAKE_CFG_INTDIR is no longer necessary for this  purpose  but	has  been
	      left for compatibility with existing projects.  Instead add_custom_command() recog-
	      nizes  executable  target  names	in   its   COMMAND   option,   so   "${CMAKE_CUR-
	      RENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/mytool" can be replaced by just "mytool".

	      This variable is read-only.  Setting it is undefined behavior.  In multi-configura-
	      tion build systems the value of this variable is passed as the value of  preproces-
	      sor symbol "CMAKE_INTDIR" to the compilation of all source files.

       CMAKE_COMMAND
	      The full path to the cmake executable.

	      This  is	the  full  path to the CMake executable cmake which is useful from custom
	      commands that want to use the cmake -E option for portable system  commands.  (e.g.
	      /usr/local/bin/cmake

       CMAKE_CROSSCOMPILING
	      Is CMake currently cross compiling.

	      This  variable  will  be set to true by CMake if CMake is cross compiling. Specifi-
	      cally if the build platform is different from the target platform.

       CMAKE_CTEST_COMMAND
	      Full path to ctest command installed with cmake.

	      This is the full path to the CTest executable ctest which  is  useful  from  custom
	      commands that want to use the cmake -E option for portable system commands.

       CMAKE_CURRENT_BINARY_DIR
	      The path to the binary directory currently being processed.

	      This  the  full  path  to  the build directory that is currently being processed by
	      cmake.  Each directory added by add_subdirectory will create a binary directory  in
	      the  build  tree,  and  as  it  is  being  processed this variable will be set. For
	      in-source builds this is the current source directory being processed.

       CMAKE_CURRENT_LIST_DIR
	      Full directory of the listfile currently being processed.

	      As CMake processes the listfiles in your project this variable will always  be  set
	      to  the directory where the listfile which is currently being processed (CMAKE_CUR-
	      RENT_LIST_FILE) is located.  The value has dynamic scope.  When CMake  starts  pro-
	      cessing commands in a source file it sets this variable to the directory where this
	      file is located.	When CMake finishes processing commands from the file it restores
	      the previous value.  Therefore the value of the variable inside a macro or function
	      is the directory of the file invoking the bottom-most entry on the call stack,  not
	      the directory of the file containing the macro or function definition.

	      See also CMAKE_CURRENT_LIST_FILE.

       CMAKE_CURRENT_LIST_FILE
	      Full path to the listfile currently being processed.

	      As  CMake  processes the listfiles in your project this variable will always be set
	      to the one currently being processed.  The value has  dynamic  scope.   When  CMake
	      starts  processing  commands in a source file it sets this variable to the location
	      of the file.  When CMake finishes processing commands from the file it restores the
	      previous	value.	Therefore the value of the variable inside a macro or function is
	      the file invoking the bottom-most entry on the call stack, not the file  containing
	      the macro or function definition.

	      See also CMAKE_PARENT_LIST_FILE.

       CMAKE_CURRENT_LIST_LINE
	      The line number of the current file being processed.

	      This is the line number of the file currently being processed by cmake.

       CMAKE_CURRENT_SOURCE_DIR
	      The path to the source directory currently being processed.

	      This  the  full  path  to the source directory that is currently being processed by
	      cmake.

       CMAKE_DL_LIBS
	      Name of library containing dlopen and dlcose.

	      The name of the library that has dlopen and dlclose in it,  usually  -ldl  on  most
	      UNIX machines.

       CMAKE_EDIT_COMMAND
	      Full path to cmake-gui or ccmake.

	      This  is the full path to the CMake executable that can graphically edit the cache.
	      For example, cmake-gui, ccmake, or cmake -i.

       CMAKE_EXECUTABLE_SUFFIX
	      The suffix for executables on this platform.

	      The suffix to use for the end of an executable if any, .exe on Windows.

	      CMAKE_EXECUTABLE_SUFFIX_<LANG> overrides this for language <LANG>.

       CMAKE_EXTRA_GENERATOR
	      The extra generator used to build the project.

	      When using the Eclipse, CodeBlocks or KDevelop generators,  CMake  generates  Make-
	      files (CMAKE_GENERATOR) and additionally project files for the respective IDE. This
	      IDE project file	generator  is  stored  in  CMAKE_EXTRA_GENERATOR  (e.g.  "Eclipse
	      CDT4").

       CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES
	      Additional suffixes for shared libraries.

	      Extensions    for    shared    libraries	  other    than    that    specified   by
	      CMAKE_SHARED_LIBRARY_SUFFIX, if any.  CMake uses this to recognize external  shared
	      library files during analysis of libraries linked by a target.

       CMAKE_GENERATOR
	      The generator used to build the project.

	      The  name  of  the generator that is being used to generate the build files.  (e.g.
	      "Unix Makefiles", "Visual Studio 6", etc.)

       CMAKE_GENERATOR_TOOLSET
	      Native build system toolset name specified by user.

	      Some CMake generators support a toolset name to be given to the native build system
	      to  choose a compiler.  If the user specifies a toolset name (e.g. via the cmake -T
	      option) the value will be available in this variable.

       CMAKE_HOME_DIRECTORY
	      Path to top of source tree.

	      This is the path to the top level of the source tree.

       CMAKE_IMPORT_LIBRARY_PREFIX
	      The prefix for import libraries that you link to.

	      The prefix to use for the name of an import library if used on this platform.

	      CMAKE_IMPORT_LIBRARY_PREFIX_<LANG> overrides this for language <LANG>.

       CMAKE_IMPORT_LIBRARY_SUFFIX
	      The suffix for import  libraries that you link to.

	      The suffix to use for the end of an import library if used on this platform.

	      CMAKE_IMPORT_LIBRARY_SUFFIX_<LANG> overrides this for language <LANG>.

       CMAKE_LINK_LIBRARY_SUFFIX
	      The suffix for libraries that you link to.

	      The suffix to use for the end of a library, .lib on Windows.

       CMAKE_MAJOR_VERSION
	      The Major version of cmake (i.e. the 2 in 2.X.X)

	      This specifies the major version of the CMake executable being run.

       CMAKE_MAKE_PROGRAM
	      See CMAKE_BUILD_TOOL.

	      This variable is around for backwards compatibility, see CMAKE_BUILD_TOOL.

       CMAKE_MINOR_VERSION
	      The Minor version of cmake (i.e. the 4 in X.4.X).

	      This specifies the minor version of the CMake executable being run.

       CMAKE_PARENT_LIST_FILE
	      Full path to the parent listfile of the one currently being processed.

	      As CMake processes the listfiles in your project this variable will always  be  set
	      to the listfile that included or somehow invoked the one currently being processed.
	      See also CMAKE_CURRENT_LIST_FILE.

       CMAKE_PATCH_VERSION
	      The patch version of cmake (i.e. the 3 in X.X.3).

	      This specifies the patch version of the CMake executable being run.

       CMAKE_PROJECT_NAME
	      The name of the current project.

	      This specifies name of the current project from the closest inherited PROJECT  com-
	      mand.

       CMAKE_RANLIB
	      Name of randomizing tool for static libraries.

	      This  specifies  name of the program that randomizes libraries on UNIX, not used on
	      Windows, but may be present.

       CMAKE_ROOT
	      Install directory for running cmake.

	      This is the install root for the running CMake and the  Modules  directory  can  be
	      found here. This is commonly used in this format: ${CMAKE_ROOT}/Modules

       CMAKE_SCRIPT_MODE_FILE
	      Full path to the -P script file currently being processed.

	      When run in -P script mode, CMake sets this variable to the full path of the script
	      file. When run to configure a CMakeLists.txt file, this variable is not set.

       CMAKE_SHARED_LIBRARY_PREFIX
	      The prefix for shared libraries that you link to.

	      The prefix to use for the name of a shared library, lib on UNIX.

	      CMAKE_SHARED_LIBRARY_PREFIX_<LANG> overrides this for language <LANG>.

       CMAKE_SHARED_LIBRARY_SUFFIX
	      The suffix for shared libraries that you link to.

	      The suffix to use for the end of a shared library, .dll on Windows.

	      CMAKE_SHARED_LIBRARY_SUFFIX_<LANG> overrides this for language <LANG>.

       CMAKE_SHARED_MODULE_PREFIX
	      The prefix for loadable modules that you link to.

	      The prefix to use for the name of a loadable module on this platform.

	      CMAKE_SHARED_MODULE_PREFIX_<LANG> overrides this for language <LANG>.

       CMAKE_SHARED_MODULE_SUFFIX
	      The suffix for shared libraries that you link to.

	      The suffix to use for the end of a loadable module on this platform

	      CMAKE_SHARED_MODULE_SUFFIX_<LANG> overrides this for language <LANG>.

       CMAKE_SIZEOF_VOID_P
	      Size of a void pointer.

	      This is set to the size of a pointer on the machine, and is  determined  by  a  try
	      compile.	If  a  64  bit size is found, then the library search path is modified to
	      look for 64 bit libraries first.

       CMAKE_SKIP_RPATH
	      If true, do not add run time path information.

	      If this is set to TRUE, then the rpath information is not added  to  compiled  exe-
	      cutables.   The  default	is  to add rpath information if the platform supports it.
	      This allows for easy running from the build tree.  To omit  RPATH  in  the  install
	      step, but not the build step, use CMAKE_SKIP_INSTALL_RPATH instead.

       CMAKE_SOURCE_DIR
	      The path to the top level of the source tree.

	      This  is	the  full  path to the top level of the current CMake source tree. For an
	      in-source build, this would be the same as CMAKE_BINARY_DIR.

       CMAKE_STANDARD_LIBRARIES
	      Libraries linked into every executable and shared library.

	      This is the list of libraries that are linked into all executables and libraries.

       CMAKE_STATIC_LIBRARY_PREFIX
	      The prefix for static libraries that you link to.

	      The prefix to use for the name of a static library, lib on UNIX.

	      CMAKE_STATIC_LIBRARY_PREFIX_<LANG> overrides this for language <LANG>.

       CMAKE_STATIC_LIBRARY_SUFFIX
	      The suffix for static libraries that you link to.

	      The suffix to use for the end of a static library, .lib on Windows.

	      CMAKE_STATIC_LIBRARY_SUFFIX_<LANG> overrides this for language <LANG>.

       CMAKE_TWEAK_VERSION
	      The tweak version of cmake (i.e. the 1 in X.X.X.1).

	      This specifies the tweak version of the CMake executable being run.   Releases  use
	      tweak  <	20000000  and  development  versions use the date format CCYYMMDD for the
	      tweak level.

       CMAKE_VERBOSE_MAKEFILE
	      Create verbose makefiles if on.

	      This variable defaults to false. You can set this variable to true  to  make  CMake
	      produce verbose makefiles that show each command line as it is used.

       CMAKE_VERSION
	      The full version of cmake in major.minor.patch[.tweak[-id]] format.

	      This  specifies  the full version of the CMake executable being run.  This variable
	      is defined by  versions  2.6.3  and  higher.   See  variables  CMAKE_MAJOR_VERSION,
	      CMAKE_MINOR_VERSION,  CMAKE_PATCH_VERSION,  and  CMAKE_TWEAK_VERSION for individual
	      version components.  The [-id] component appears in non-release versions and may be
	      arbitrary text.

       CMAKE_VS_PLATFORM_TOOLSET
	      Visual Studio Platform Toolset name.

	      VS  10  and  above  use  MSBuild	under  the  hood  and  support	multiple compiler
	      toolchains.  CMake may specify a toolset explicitly, such as "v110" for  VS  11  or
	      "Windows7.1SDK"  for  64-bit  support in VS 10 Express.  CMake provides the name of
	      the chosen toolset in this variable.

       CMAKE_XCODE_PLATFORM_TOOLSET
	      Xcode compiler selection.

	      Xcode supports selection of a compiler from one of the installed	toolsets.   CMake
	      provides	the  name  of  the  chosen toolset in this variable, if any is explicitly
	      selected (e.g. via the cmake -T option).

       PROJECT_BINARY_DIR
	      Full path to build directory for project.

	      This is the binary directory of the most recent PROJECT command.

       PROJECT_NAME
	      Name of the project given to the project command.

	      This is the name given to the most recent PROJECT command.

       PROJECT_SOURCE_DIR
	      Top level source directory for the current project.

	      This is the source directory of the most recent PROJECT command.

       [Project name]_BINARY_DIR
	      Top level binary directory for the named project.

	      A variable is created with the name used in the PROJECT command, and is the  binary
	      directory for the project.   This can be useful when SUBDIR is used to connect sev-
	      eral projects.

       [Project name]_SOURCE_DIR
	      Top level source directory for the named project.

	      A variable is created with the name used in the PROJECT command, and is the  source
	      directory  for  the  project.   This can be useful when add_subdirectory is used to
	      connect several projects.

VARIABLES THAT CHANGE BEHAVIOR
       BUILD_SHARED_LIBS
	      Global flag to cause add_library to create shared libraries if on.

	      If present and true, this will cause all libraries to be built  shared  unless  the
	      library  was explicitly added as a static library.  This variable is often added to
	      projects as an OPTION so that each user of a project can decide  if  they  want  to
	      build the project using shared or static libraries.

       CMAKE_ABSOLUTE_DESTINATION_FILES
	      List of files which have been installed using  an ABSOLUTE DESTINATION path.

	      This  variable is defined by CMake-generated cmake_install.cmake scripts. It can be
	      used (read-only) by program or script that source those install  scripts.  This  is
	      used by some CPack generators (e.g. RPM).

       CMAKE_AUTOMOC_RELAXED_MODE
	      Switch between strict and relaxed automoc mode.

	      By  default, automoc behaves exactly as described in the documentation of the AUTO-
	      MOC target property.  When set to TRUE, it accepts more input and tries to find the
	      correct  input  file  for  moc even if it differs from the documented behaviour. In
	      this mode it e.g. also checks whether a header file is intended to be processed  by
	      moc when a "foo.moc" file has been included.

	      Relaxed mode has to be enabled for KDE4 compatibility.

       CMAKE_BACKWARDS_COMPATIBILITY
	      Version of cmake required to build project

	      From  the  point of view of backwards compatibility, this specifies what version of
	      CMake should be supported. By default this value is the  version	number	of  CMake
	      that you are running. You can set this to an older version of CMake to support dep-
	      recated commands of CMake in projects that were written to use  older  versions  of
	      CMake. This can be set by the user or set at the beginning of a CMakeLists file.

       CMAKE_BUILD_TYPE
	      Specifies the build type for make based generators.

	      This  specifies  what  build  type will be built in this tree.  Possible values are
	      empty, Debug, Release, RelWithDebInfo and MinSizeRel. This variable  is  only  sup-
	      ported  for  make  based generators. If this variable is supported, then CMake will
	      also   provide   initial	 values    for	  the	 variables    with    the    name
	      CMAKE_C_FLAGS_[DEBUG|RELEASE|RELWITHDEBINFO|MINSIZEREL].	   For	   example,    if
	      CMAKE_BUILD_TYPE	is  Debug,  then  CMAKE_C_FLAGS_DEBUG  will  be  added	 to   the
	      CMAKE_C_FLAGS.

       CMAKE_COLOR_MAKEFILE
	      Enables color output when using the Makefile generator.

	      When enabled, the generated Makefiles will produce colored output. Default is ON.

       CMAKE_CONFIGURATION_TYPES
	      Specifies the available build types.

	      This  specifies what build types will be available such as Debug, Release, RelWith-
	      DebInfo etc. This has reasonable defaults on most platforms. But can be extended to
	      provide other build types. See also CMAKE_BUILD_TYPE.

       CMAKE_DEBUG_TARGET_PROPERTIES
	      Enables tracing output for target properties.

	      This  variable  can be populated with a list of properties to generate debug output
	      for when evaluating target properties.  Currently it can only be used when evaluat-
	      ing  the INCLUDE_DIRECTORIES target property.  In that case, it outputs a backtrace
	      for each include directory in the build.	Default is unset.

       CMAKE_DISABLE_FIND_PACKAGE_<PackageName>
	      Variable for disabling find_package() calls.

	      Every non-REQUIRED find_package() call in a project can be disabled by setting  the
	      variable	CMAKE_DISABLE_FIND_PACKAGE_<PackageName>  to  TRUE.  This  can be used to
	      build a project without an optional package, although that package is installed.

	      This switch should be used during the initial CMake run. Otherwise if  the  package
	      has  already  been  found  in  a	previous CMake run, the variables which have been
	      stored in the cache will still be there. In the case it is  recommended  to  remove
	      the cache variables for this package from the cache using the cache editor or cmake
	      -U

       CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION
	      Ask cmake_install.cmake script to error out as soon as a file with absolute INSTALL
	      DESTINATION is encountered.

	      The  fatal  error  is  emitted  before the installation of the offending file takes
	      place. This variable is used by  CMake-generated	cmake_install.cmake  scripts.  If
	      ones  set this variable to ON while running the script, it may get fatal error mes-
	      sages from the script.

       CMAKE_FIND_LIBRARY_PREFIXES
	      Prefixes to prepend when looking for libraries.

	      This specifies what prefixes to add to library names when the find_library  command
	      looks  for libraries. On UNIX systems this is typically lib, meaning that when try-
	      ing to find the foo library it will look for libfoo.

       CMAKE_FIND_LIBRARY_SUFFIXES
	      Suffixes to append when looking for libraries.

	      This specifies what suffixes to add to library names when the find_library  command
	      looks  for  libraries.  On Windows systems this is typically .lib and .dll, meaning
	      that when trying to find the foo library it will look for foo.dll etc.

       CMAKE_FIND_PACKAGE_WARN_NO_MODULE
	      Tell find_package to warn if called without an explicit mode.

	      If find_package is called without  an  explicit  mode  option  (MODULE,  CONFIG  or
	      NO_MODULE) and no Find<pkg>.cmake module is in CMAKE_MODULE_PATH then CMake implic-
	      itly assumes that the caller intends to search for a  package  configuration  file.
	      If  no  package configuration file is found then the wording of the failure message
	      must account for both the case that the package is really missing and the case that
	      the  project  has a bug and failed to provide the intended Find module.  If instead
	      the caller specifies an explicit mode option then the failure message can  be  more
	      specific.

	      Set  CMAKE_FIND_PACKAGE_WARN_NO_MODULE to TRUE to tell find_package to warn when it
	      implicitly assumes Config mode.  This helps developers enforce use of  an  explicit
	      mode in all calls to find_package within a project.

       CMAKE_IGNORE_PATH
	      Path to be ignored by FIND_XXX() commands.

	      Specifies  directories  to  be ignored by searches in FIND_XXX() commands.  This is
	      useful in cross-compiled environments where some system directories contain  incom-
	      patible  but  possibly  linkable	libraries. For example, on cross-compiled cluster
	      environments, this allows a user to ignore directories containing  libraries  meant
	      for  the	front-end  machine  that modules like FindX11 (and others) would normally
	      search. By default this is empty; it is intended to be set  by  the  project.  Note
	      that  CMAKE_IGNORE_PATH takes a list of directory names, NOT a list of prefixes. If
	      you want to ignore paths under prefixes (bin, include, lib, etc.), you'll  need  to
	      specify	them   explicitly.   See   also   CMAKE_PREFIX_PATH,  CMAKE_LIBRARY_PATH,
	      CMAKE_INCLUDE_PATH, CMAKE_PROGRAM_PATH.

       CMAKE_INCLUDE_PATH
	      Path used for searching by FIND_FILE() and FIND_PATH().

	      Specifies a path which will be used both by FIND_FILE() and FIND_PATH(). Both  com-
	      mands  will  check  each of the contained directories for the existence of the file
	      which is currently searched. By default it is empty, it is intended to  be  set  by
	      the project. See also CMAKE_SYSTEM_INCLUDE_PATH, CMAKE_PREFIX_PATH.

       CMAKE_INSTALL_DEFAULT_COMPONENT_NAME
	      Default component used in install() commands.

	      If an install() command is used without the COMPONENT argument, these files will be
	      grouped into a default component. The name of this default install  component  will
	      be taken from this variable.  It defaults to "Unspecified".

       CMAKE_INSTALL_PREFIX
	      Install directory used by install.

	      If "make install" is invoked or INSTALL is built, this directory is pre-pended onto
	      all install directories. This variable defaults to /usr/local on UNIX  and  c:/Pro-
	      gram Files on Windows.

	      On  UNIX one can use the DESTDIR mechanism in order to relocate the whole installa-
	      tion. DESTDIR means DESTination DIRectory. It is commonly used by makefile users in
	      order to install software at non-default location. It is usually invoked like this:

	       make DESTDIR=/home/john install

	      which  will  install  the  concerned  software  using the installation prefix, e.g.
	      "/usr/local"   pre-pended   with	 the   DESTDIR	 value	 which	 finally    gives
	      "/home/john/usr/local".

	      WARNING:	DESTDIR  may  not  be used on Windows because installation prefix usually
	      contains a drive letter like in "C:/Program Files" which cannot be pre-pended  with
	      some other prefix.

       CMAKE_LIBRARY_PATH
	      Path used for searching by FIND_LIBRARY().

	      Specifies  a  path  which will be used by FIND_LIBRARY(). FIND_LIBRARY() will check
	      each of the contained directories for the existence of the library  which  is  cur-
	      rently  searched.  By default it is empty, it is intended to be set by the project.
	      See also CMAKE_SYSTEM_LIBRARY_PATH, CMAKE_PREFIX_PATH.

       CMAKE_MFC_FLAG
	      Tell cmake to use MFC for an executable or dll.

	      This can be set in a CMakeLists.txt file and will enable MFC  in	the  application.
	      It should be set to 1 for the static MFC library, and 2 for the shared MFC library.
	      This is used in Visual Studio 6 and 7 project files.   The CMakeSetup  dialog  used
	      MFC and the CMakeLists.txt looks like this:

		add_definitions(-D_AFXDLL)
		set(CMAKE_MFC_FLAG 2)
		add_executable(CMakeSetup WIN32 ${SRCS})

       CMAKE_MODULE_PATH
	      List of directories to search for CMake modules.

	      Commands	like  include() and find_package() search for files in directories listed
	      by this variable before checking the default modules that come with CMake.

       CMAKE_NOT_USING_CONFIG_FLAGS
	      Skip _BUILD_TYPE flags if true.

	      This is an internal flag used by the generators in CMake to tell CMake to skip  the
	      _BUILD_TYPE flags.

       CMAKE_POLICY_DEFAULT_CMP<NNNN>
	      Default for CMake Policy CMP<NNNN> when it is otherwise left unset.

	      Commands cmake_minimum_required(VERSION) and cmake_policy(VERSION) by default leave
	      policies	 introduced   after   the   given   version   unset.	Set    CMAKE_POL-
	      ICY_DEFAULT_CMP<NNNN>  to  OLD  or NEW to specify the default for policy CMP<NNNN>,
	      where <NNNN> is the policy number.

	      This variable should not be set by a project in CMake code;  use	cmake_policy(SET)
	      instead.	Users running CMake may set this variable in the cache (e.g. -DCMAKE_POL-
	      ICY_DEFAULT_CMP<NNNN>=<OLD|NEW>) to set a policy not otherwise set by the  project.
	      Set  to  OLD  to	quiet  a policy warning while using old behavior or to NEW to try
	      building the project with new behavior.

       CMAKE_PREFIX_PATH
	      Path used for searching by FIND_XXX(), with appropriate suffixes added.

	      Specifies a path which will be used by the FIND_XXX()  commands.	It  contains  the
	      "base"  directories,  the  FIND_XXX() commands append appropriate subdirectories to
	      the base directories. So FIND_PROGRAM() adds /bin to each of the directories in the
	      path,  FIND_LIBRARY()  appends /lib to each of the directories, and FIND_PATH() and
	      FIND_FILE() append /include . By default it is empty, it is intended to be  set  by
	      the     project.	  See	 also	 CMAKE_SYSTEM_PREFIX_PATH,    CMAKE_INCLUDE_PATH,
	      CMAKE_LIBRARY_PATH, CMAKE_PROGRAM_PATH.

       CMAKE_PROGRAM_PATH
	      Path used for searching by FIND_PROGRAM().

	      Specifies a path which will be used by FIND_PROGRAM().  FIND_PROGRAM()  will  check
	      each  of	the  contained directories for the existence of the program which is cur-
	      rently searched. By default it is empty, it is intended to be set by  the  project.
	      See also CMAKE_SYSTEM_PROGRAM_PATH,  CMAKE_PREFIX_PATH.

       CMAKE_SKIP_INSTALL_ALL_DEPENDENCY
	      Don't make the install target depend on the all target.

	      By  default, the "install" target depends on the "all" target. This has the effect,
	      that when "make install" is invoked or INSTALL is built, first the "all" target  is
	      built, then the installation starts. If CMAKE_SKIP_INSTALL_ALL_DEPENDENCY is set to
	      TRUE, this dependency is not created, so the installation process will start  imme-
	      diately, independent from whether the project has been completely built or not.

       CMAKE_SYSTEM_IGNORE_PATH
	      Path to be ignored by FIND_XXX() commands.

	      Specifies  directories  to  be ignored by searches in FIND_XXX() commands.  This is
	      useful in cross-compiled environments where some system directories contain  incom-
	      patible  but  possibly  linkable	libraries. For example, on cross-compiled cluster
	      environments, this allows a user to ignore directories containing  libraries  meant
	      for  the	front-end  machine  that modules like FindX11 (and others) would normally
	      search. By default this contains a  list	of  directories  containing  incompatible
	      binaries	for  the  host	system.  See  also  CMAKE_SYSTEM_PREFIX_PATH,  CMAKE_SYS-
	      TEM_LIBRARY_PATH, CMAKE_SYSTEM_INCLUDE_PATH, and CMAKE_SYSTEM_PROGRAM_PATH.

       CMAKE_SYSTEM_INCLUDE_PATH
	      Path used for searching by FIND_FILE() and FIND_PATH().

	      Specifies a path which will be used both by FIND_FILE() and FIND_PATH(). Both  com-
	      mands  will  check  each of the contained directories for the existence of the file
	      which is currently searched. By default it contains the  standard  directories  for
	      the  current  system.  It  is  NOT  intended  to	be  modified  by the project, use
	      CMAKE_INCLUDE_PATH for this. See also CMAKE_SYSTEM_PREFIX_PATH.

       CMAKE_SYSTEM_LIBRARY_PATH
	      Path used for searching by FIND_LIBRARY().

	      Specifies a path which will be used by FIND_LIBRARY().  FIND_LIBRARY()  will  check
	      each  of	the  contained directories for the existence of the library which is cur-
	      rently searched. By default it contains the standard directories	for  the  current
	      system.  It  is  NOT intended to be modified by the project, use CMAKE_LIBRARY_PATH
	      for this. See also CMAKE_SYSTEM_PREFIX_PATH.

       CMAKE_SYSTEM_PREFIX_PATH
	      Path used for searching by FIND_XXX(), with appropriate suffixes added.

	      Specifies a path which will be used by the FIND_XXX()  commands.	It  contains  the
	      "base"  directories,  the  FIND_XXX() commands append appropriate subdirectories to
	      the base directories. So FIND_PROGRAM() adds /bin to each of the directories in the
	      path,  FIND_LIBRARY()  appends /lib to each of the directories, and FIND_PATH() and
	      FIND_FILE() append /include . By default this contains the standard directories for
	      the  current  system.  It  is  NOT  intended  to	be  modified  by the project, use
	      CMAKE_PREFIX_PATH  for  this.  See   also   CMAKE_SYSTEM_INCLUDE_PATH,   CMAKE_SYS-
	      TEM_LIBRARY_PATH, CMAKE_SYSTEM_PROGRAM_PATH, and CMAKE_SYSTEM_IGNORE_PATH.

       CMAKE_SYSTEM_PROGRAM_PATH
	      Path used for searching by FIND_PROGRAM().

	      Specifies  a  path  which will be used by FIND_PROGRAM(). FIND_PROGRAM() will check
	      each of the contained directories for the existence of the program  which  is  cur-
	      rently  searched.  By  default it contains the standard directories for the current
	      system. It is NOT intended to be modified by the	project,  use  CMAKE_PROGRAM_PATH
	      for this. See also CMAKE_SYSTEM_PREFIX_PATH.

       CMAKE_USER_MAKE_RULES_OVERRIDE
	      Specify a CMake file that overrides platform information.

	      CMake loads the specified file while enabling support for each language from either
	      the project() or enable_language() commands.  It is loaded  after  CMake's  builtin
	      compiler	and platform information modules have been loaded but before the informa-
	      tion is used.  The file may set platform information variables to override  CMake's
	      defaults.

	      This feature is intended for use only in overriding information variables that must
	      be set before CMake builds its first test project to check that the compiler for	a
	      language	works.	 It  should  not  be  used  to load a file in cases that a normal
	      include() will work.  Use it only as a last resort  for  behavior  that  cannot  be
	      achieved	any other way.	For example, one may set CMAKE_C_FLAGS_INIT to change the
	      default value used to initialize CMAKE_C_FLAGS before it is cached.   The  override
	      file  should  NOT  be  used  to  set anything that could be set after languages are
	      enabled, such as variables  like	CMAKE_RUNTIME_OUTPUT_DIRECTORY	that  affect  the
	      placement  of  binaries.	 Information set in the file will be used for try_compile
	      and try_run builds too.

       CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION
	      Ask cmake_install.cmake script to warn each time a file with absolute INSTALL  DES-
	      TINATION is encountered.

	      This  variable  is used by CMake-generated cmake_install.cmake scripts. If ones set
	      this variable to ON while running the script, it may get warning messages from  the
	      script.

VARIABLES THAT DESCRIBE THE SYSTEM
       APPLE  True if running on Mac OSX.

	      Set to true on Mac OSX.

       BORLAND
	      True if the borland compiler is being used.

	      This is set to true if the Borland compiler is being used.

       CMAKE_CL_64
	      Using the 64 bit compiler from Microsoft

	      Set to true when using the 64 bit cl compiler from Microsoft.

       CMAKE_COMPILER_2005
	      Using the Visual Studio 2005 compiler from Microsoft

	      Set to true when using the Visual Studio 2005 compiler from Microsoft.

       CMAKE_HOST_APPLE
	      True for Apple OSXoperating systems.

	      Set to true when the host system is Apple OSX.

       CMAKE_HOST_SYSTEM
	      Name of system cmake is being run on.

	      The  same as CMAKE_SYSTEM but for the host system instead of the target system when
	      cross compiling.

       CMAKE_HOST_SYSTEM_NAME
	      Name of the OS CMake is running on.

	      The same as CMAKE_SYSTEM_NAME but for the host system instead of the target  system
	      when cross compiling.

       CMAKE_HOST_SYSTEM_PROCESSOR
	      The name of the CPU CMake is running on.

	      The  same  as  CMAKE_SYSTEM_PROCESSOR but for the host system instead of the target
	      system when cross compiling.

       CMAKE_HOST_SYSTEM_VERSION
	      OS version CMake is running on.

	      The same as CMAKE_SYSTEM_VERSION but for the host system instead of the target sys-
	      tem when cross compiling.

       CMAKE_HOST_UNIX
	      True for UNIX and UNIX like operating systems.

	      Set to true when the host system is UNIX or UNIX like (i.e. APPLE and CYGWIN).

       CMAKE_HOST_WIN32
	      True on windows systems, including win64.

	      Set to true when the host system is Windows and on cygwin.

       CMAKE_LIBRARY_ARCHITECTURE
	      Target architecture library directory name, if detected.

	      This  is	the value of CMAKE_<lang>_LIBRARY_ARCHITECTURE as detected for one of the
	      enabled languages.

       CMAKE_LIBRARY_ARCHITECTURE_REGEX
	      Regex matching possible target architecture library directory names.

	      This is used to detect CMAKE_<lang>_LIBRARY_ARCHITECTURE from the  implicit  linker
	      search path by matching the <arch> name.

       CMAKE_OBJECT_PATH_MAX
	      Maximum object file full-path length allowed by native build tools.

	      CMake  computes  for  every  source  file an object file name that is unique to the
	      source file and deterministic with respect to the full path  to  the  source  file.
	      This allows multiple source files in a target to share the same name if they lie in
	      different directories without rebuilding when one is added or removed.  However, it
	      can  produce  long  full	paths  in a few cases, so CMake shortens the path using a
	      hashing scheme when the full path to an object file exceeds a limit.  CMake  has	a
	      built-in	limit  for  each  platform  that is sufficient for common tools, but some
	      native tools may have a lower limit.  This variable may be set to specify the limit
	      explicitly.  The value must be an integer no less than 128.

       CMAKE_SYSTEM
	      Name of system cmake is compiling for.

	      This  variable is the composite of CMAKE_SYSTEM_NAME and CMAKE_SYSTEM_VERSION, like
	      this ${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_VERSION}. If CMAKE_SYSTEM_VERSION  is  not
	      set, then CMAKE_SYSTEM is the same as CMAKE_SYSTEM_NAME.

       CMAKE_SYSTEM_NAME
	      Name of the OS CMake is building for.

	      This  is the name of the operating system on which CMake is targeting.   On systems
	      that have the uname command, this variable is  set  to  the  output  of  uname  -s.
	      Linux,  Windows,	 and  Darwin  for  Mac OSX are the values found  on the big three
	      operating systems.

       CMAKE_SYSTEM_PROCESSOR
	      The name of the CPU CMake is building for.

	      On systems that support uname, this variable is set to the output of uname  -p,  on
	      windows it is set to the value of the environment variable PROCESSOR_ARCHITECTURE

       CMAKE_SYSTEM_VERSION
	      OS version CMake is building for.

	      A  numeric version string for the system, on systems that support uname, this vari-
	      able is set to the output of uname -r. On other systems this is set to  major-minor
	      version numbers.

       CYGWIN True for cygwin.

	      Set to true when using CYGWIN.

       MSVC   True when using Microsoft Visual C

	      Set to true when the compiler is some version of Microsoft Visual C.

       MSVC10 True when using Microsoft Visual C 10.0

	      Set to true when the compiler is version 10.0 of Microsoft Visual C.

       MSVC11 True when using Microsoft Visual C 11.0

	      Set to true when the compiler is version 11.0 of Microsoft Visual C.

       MSVC60 True when using Microsoft Visual C 6.0

	      Set to true when the compiler is version 6.0 of Microsoft Visual C.

       MSVC70 True when using Microsoft Visual C 7.0

	      Set to true when the compiler is version 7.0 of Microsoft Visual C.

       MSVC71 True when using Microsoft Visual C 7.1

	      Set to true when the compiler is version 7.1 of Microsoft Visual C.

       MSVC80 True when using Microsoft Visual C 8.0

	      Set to true when the compiler is version 8.0 of Microsoft Visual C.

       MSVC90 True when using Microsoft Visual C 9.0

	      Set to true when the compiler is version 9.0 of Microsoft Visual C.

       MSVC_IDE
	      True when using the Microsoft Visual C IDE

	      Set  to  true when the target platform is the Microsoft Visual C IDE, as opposed to
	      the command line compiler.

       MSVC_VERSION
	      The version of Microsoft Visual C/C++ being used if any.

	      Known version numbers are:

		1200 = VS  6.0
		1300 = VS  7.0
		1310 = VS  7.1
		1400 = VS  8.0
		1500 = VS  9.0
		1600 = VS 10.0
		1700 = VS 11.0

       UNIX   True for UNIX and UNIX like operating systems.

	      Set to true when the target system is UNIX or UNIX like (i.e. APPLE and CYGWIN).

       WIN32  True on windows systems, including win64.

	      Set to true when the target system is Windows.

       XCODE_VERSION
	      Version of Xcode (Xcode generator only).

	      Under  the  Xcode  generator,  this  is  the  version  of  Xcode	as  specified  in
	      "Xcode.app/Contents/version.plist" (such as "3.1.2").

VARIABLES THAT CONTROL THE BUILD
       CMAKE_<CONFIG>_POSTFIX
	      Default filename postfix for libraries under configuration <CONFIG>.

	      When  a  non-executable  target  is created its <CONFIG>_POSTFIX target property is
	      initialized with the value of this variable if it is set.

       CMAKE_ARCHIVE_OUTPUT_DIRECTORY
	      Where to put all the ARCHIVE targets when built.

	      This variable is used to initialize the ARCHIVE_OUTPUT_DIRECTORY	property  on  all
	      the targets. See that target property for additional information.

       CMAKE_AUTOMOC
	      Whether to handle moc automatically for Qt targets.

	      This  variable  is  used to initialize the AUTOMOC property on all the targets. See
	      that target property for additional information.

       CMAKE_AUTOMOC_MOC_OPTIONS
	      Additional options for moc when using automoc (see CMAKE_AUTOMOC).

	      This variable is used to initialize the AUTOMOC_MOC_OPTIONS  property  on  all  the
	      targets. See that target property for additional information.

       CMAKE_BUILD_WITH_INSTALL_RPATH
	      Use the install path for the RPATH

	      Normally	CMake  uses the build tree for the RPATH when building executables etc on
	      systems that use RPATH. When the software is  installed  the  executables  etc  are
	      relinked	by  CMake to have the install RPATH. If this variable is set to true then
	      the software is always built with the install path for the RPATH and does not  need
	      to be relinked when installed.

       CMAKE_DEBUG_POSTFIX
	      See variable CMAKE_<CONFIG>_POSTFIX.

	      This variable is a special case of the more-general CMAKE_<CONFIG>_POSTFIX variable
	      for the DEBUG configuration.

       CMAKE_EXE_LINKER_FLAGS
	      Linker flags used to create executables.

	      Flags used by the linker when creating an executable.

       CMAKE_EXE_LINKER_FLAGS_[CMAKE_BUILD_TYPE]
	      Flag used when linking an executable.

	      Same as CMAKE_C_FLAGS_* but used by the linker when creating executables.

       CMAKE_Fortran_FORMAT
	      Set to FIXED or FREE to indicate the Fortran source layout.

	      This variable is used to initialize the Fortran_FORMAT property on all the targets.
	      See that target property for additional information.

       CMAKE_Fortran_MODULE_DIRECTORY
	      Fortran module output directory.

	      This  variable  is  used to initialize the Fortran_MODULE_DIRECTORY property on all
	      the targets. See that target property for additional information.

       CMAKE_GNUtoMS
	      Convert GNU import libraries (.dll.a) to MS format (.lib).

	      This variable is used to initialize the GNUtoMS property on targets when	they  are
	      created.	See that target property for additional information.

       CMAKE_INCLUDE_CURRENT_DIR
	      Automatically add the current source- and build directories to the include path.

	      If   this   variable  is	enabled,  CMake  automatically	adds  in  each	directory
	      ${CMAKE_CURRENT_SOURCE_DIR} and ${CMAKE_CURRENT_BINARY_DIR} to the include path for
	      this  directory. These additional include directories do not propagate down to sub-
	      directories. This is useful mainly for out-of-source builds, where files	generated
	      into the build tree are included by files located in the source tree.

	      By default CMAKE_INCLUDE_CURRENT_DIR is OFF.

       CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE
	      Automatically  add  the  current	source-  and  build  directories  to  the  INTER-
	      FACE_INCLUDE_DIRECTORIES.

	      If this variable is enabled, CMake automatically adds for each shared library  tar-
	      get,  static  library  target,  module  target  and executable target, ${CMAKE_CUR-
	      RENT_SOURCE_DIR} and ${CMAKE_CURRENT_BINARY_DIR} to the  INTERFACE_INCLUDE_DIRECTO-
	      RIES.By default CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE is OFF.

       CMAKE_INSTALL_NAME_DIR
	      Mac OSX directory name for installed targets.

	      CMAKE_INSTALL_NAME_DIR  is  used to initialize the INSTALL_NAME_DIR property on all
	      targets. See that target property for more information.

       CMAKE_INSTALL_RPATH
	      The rpath to use for installed targets.

	      A semicolon-separated list specifying the rpath to use in  installed  targets  (for
	      platforms  that  support	it).  This  is	used  to  initialize  the target property
	      INSTALL_RPATH for all targets.

       CMAKE_INSTALL_RPATH_USE_LINK_PATH
	      Add paths to linker search and installed rpath.

	      CMAKE_INSTALL_RPATH_USE_LINK_PATH is a boolean that if  set  to  true  will  append
	      directories in the linker search path and outside the project to the INSTALL_RPATH.
	      This is used to initialize the target property INSTALL_RPATH_USE_LINK_PATH for  all
	      targets.

       CMAKE_LIBRARY_OUTPUT_DIRECTORY
	      Where to put all the LIBRARY targets when built.

	      This  variable  is  used to initialize the LIBRARY_OUTPUT_DIRECTORY property on all
	      the targets. See that target property for additional information.

       CMAKE_LIBRARY_PATH_FLAG
	      The flag used to add a library search path to a compiler.

	      The flag used to specify a library directory to the  compiler.  On  most	compilers
	      this is "-L".

       CMAKE_LINK_DEF_FILE_FLAG
	      Linker flag used to specify a .def file for dll creation.

	      The  flag  used  to  add	a  .def file when creating a dll on Windows, this is only
	      defined on Windows.

       CMAKE_LINK_DEPENDS_NO_SHARED
	      Whether to skip link dependencies on shared library files.

	      This variable initializes the LINK_DEPENDS_NO_SHARED property on targets when  they
	      are created.  See that target property for additional information.

       CMAKE_LINK_INTERFACE_LIBRARIES
	      Default value for LINK_INTERFACE_LIBRARIES of targets.

	      This  variable  is  used to initialize the LINK_INTERFACE_LIBRARIES property on all
	      the targets. See that target property for additional information.

       CMAKE_LINK_LIBRARY_FILE_FLAG
	      Flag used to link a library specified by a path to its file.

	      The flag used before a library file path is given to the linker.	 This  is  needed
	      only on very few platforms.

       CMAKE_LINK_LIBRARY_FLAG
	      Flag used to link a library into an executable.

	      The  flag  used  to  specify a library to link to an executable.	On most compilers
	      this is "-l".

       CMAKE_MACOSX_BUNDLE
	      Default value for MACOSX_BUNDLE of targets.

	      This variable is used to initialize the MACOSX_BUNDLE property on all the  targets.
	      See that target property for additional information.

       CMAKE_NO_BUILTIN_CHRPATH
	      Do not use the builtin ELF editor to fix RPATHs on installation.

	      When  an ELF binary needs to have a different RPATH after installation than it does
	      in the build tree, CMake uses a builtin editor to change the RPATH in the installed
	      copy.   If  this	variable  is set to true then CMake will relink the binary before
	      installation instead of using its builtin editor.

       CMAKE_PDB_OUTPUT_DIRECTORY
	      Where to put all the MS debug symbol files.

	      This variable is used to initialize the PDB_OUTPUT_DIRECTORY property  on  all  the
	      targets. See that target property for additional information.

       CMAKE_POSITION_INDEPENDENT_CODE
	      Default value for POSITION_INDEPENDENT_CODE of targets.

	      This  variable  is used to initialize the POSITION_INDEPENDENT_CODE property on all
	      the targets. See that target property for additional information.

       CMAKE_RUNTIME_OUTPUT_DIRECTORY
	      Where to put all the RUNTIME targets when built.

	      This variable is used to initialize the RUNTIME_OUTPUT_DIRECTORY	property  on  all
	      the targets. See that target property for additional information.

       CMAKE_SKIP_BUILD_RPATH
	      Do not include RPATHs in the build tree.

	      Normally	CMake  uses the build tree for the RPATH when building executables etc on
	      systems that use RPATH. When the software is  installed  the  executables  etc  are
	      relinked	by  CMake to have the install RPATH. If this variable is set to true then
	      the software is always built with no RPATH.

       CMAKE_SKIP_INSTALL_RPATH
	      Do not include RPATHs in the install tree.

	      Normally CMake uses the build tree for the RPATH when building executables  etc  on
	      systems  that  use  RPATH.  When	the software is installed the executables etc are
	      relinked by CMake to have the install RPATH. If this variable is set to  true  then
	      the  software  is  always  installed  without  RPATH, even if RPATH is enabled when
	      building.  This can be useful for example to allow running  tests  from  the  build
	      directory  with  RPATH enabled before the installation step.  To omit RPATH in both
	      the build and install steps, use CMAKE_SKIP_RPATH instead.

       CMAKE_TRY_COMPILE_CONFIGURATION
	      Build configuration used for try_compile and try_run projects.

	      Projects built by try_compile and try_run are built synchronously during the  CMake
	      configuration  step.   Therefore a specific build configuration must be chosen even
	      if the generated build system supports multiple configurations.

       CMAKE_USE_RELATIVE_PATHS
	      Use relative paths (May not work!).

	      If this is set to TRUE, then the CMake will use relative paths between  the  source
	      and binary tree. This option does not work for more complicated projects, and rela-
	      tive paths are used when possible.  In general, it is not possible  to  move  CMake
	      generated  makefiles  to a different location regardless of the value of this vari-
	      able.

       CMAKE_WIN32_EXECUTABLE
	      Default value for WIN32_EXECUTABLE of targets.

	      This variable is used to initialize the WIN32_EXECUTABLE property on all	the  tar-
	      gets. See that target property for additional information.

       EXECUTABLE_OUTPUT_PATH
	      Old executable location variable.

	      The  target property RUNTIME_OUTPUT_DIRECTORY supercedes this variable for a target
	      if it is set.  Executable targets are otherwise placed in this directory.

       LIBRARY_OUTPUT_PATH
	      Old library location variable.

	      The target properties ARCHIVE_OUTPUT_DIRECTORY, LIBRARY_OUTPUT_DIRECTORY, and  RUN-
	      TIME_OUTPUT_DIRECTORY  supercede	this  variable	for  a	target	if  they are set.
	      Library targets are otherwise placed in this directory.

VARIABLES FOR LANGUAGES
       CMAKE_<LANG>_ARCHIVE_APPEND
	      Rule variable to append to a static archive.

	      This is a rule variable that tells CMake how to append to a static archive.  It  is
	      used  in	place of CMAKE_<LANG>_CREATE_STATIC_LIBRARY on some platforms in order to
	      support  large   object	counts.    See	 also	CMAKE_<LANG>_ARCHIVE_CREATE   and
	      CMAKE_<LANG>_ARCHIVE_FINISH.

       CMAKE_<LANG>_ARCHIVE_CREATE
	      Rule variable to create a new static archive.

	      This  is	a  rule  variable that tells CMake how to create a static archive.  It is
	      used in place of CMAKE_<LANG>_CREATE_STATIC_LIBRARY on some platforms in	order  to
	      support	large	object	 counts.    See   also	 CMAKE_<LANG>_ARCHIVE_APPEND  and
	      CMAKE_<LANG>_ARCHIVE_FINISH.

       CMAKE_<LANG>_ARCHIVE_FINISH
	      Rule variable to finish an existing static archive.

	      This is a rule variable that tells CMake how to finish a	static	archive.   It  is
	      used  in	place of CMAKE_<LANG>_CREATE_STATIC_LIBRARY on some platforms in order to
	      support  large   object	counts.    See	 also	CMAKE_<LANG>_ARCHIVE_CREATE   and
	      CMAKE_<LANG>_ARCHIVE_APPEND.

       CMAKE_<LANG>_COMPILER
	      The full path to the compiler for LANG.

	      This is the command that will be used as the <LANG> compiler. Once set, you can not
	      change this variable.

       CMAKE_<LANG>_COMPILER_ABI
	      An internal variable subject to change.

	      This is used in determining the compiler ABI and is subject to change.

       CMAKE_<LANG>_COMPILER_ID
	      Compiler identification string.

	      A short string unique to the compiler vendor.  Possible values include:

		Absoft = Absoft Fortran (absoft.com)
		ADSP = Analog VisualDSP++ (analog.com)
		Clang = LLVM Clang (clang.llvm.org)
		Cray = Cray Compiler (cray.com)
		Embarcadero, Borland = Embarcadero (embarcadero.com)
		G95 = G95 Fortran (g95.org)
		GNU = GNU Compiler Collection (gcc.gnu.org)
		HP = Hewlett-Packard Compiler (hp.com)
		Intel = Intel Compiler (intel.com)
		MIPSpro = SGI MIPSpro (sgi.com)
		MSVC = Microsoft Visual Studio (microsoft.com)
		PGI = The Portland Group (pgroup.com)
		PathScale = PathScale (pathscale.com)
		SDCC = Small Device C Compiler (sdcc.sourceforge.net)
		SunPro = Oracle Solaris Studio (oracle.com)
		TI = Texas Instruments (ti.com)
		TinyCC = Tiny C Compiler (tinycc.org)
		Watcom = Open Watcom (openwatcom.org)
		XL, VisualAge, zOS = IBM XL (ibm.com)

	      This variable is not guaranteed to be defined for all compilers or languages.

       CMAKE_<LANG>_COMPILER_LOADED
	      Defined to true if the language is enabled.

	      When language <LANG> is enabled by project() or enable_language() this variable  is
	      defined to 1.

       CMAKE_<LANG>_COMPILER_VERSION
	      Compiler version string.

	      Compiler	version  in  major[.minor[.patch[.tweak]]]  format.  This variable is not
	      guaranteed to be defined for all compilers or languages.

       CMAKE_<LANG>_COMPILE_OBJECT
	      Rule variable to compile a single object file.

	      This is a rule variable that tells CMake how to compile a single	object	file  for
	      for the language <LANG>.

       CMAKE_<LANG>_CREATE_SHARED_LIBRARY
	      Rule variable to create a shared library.

	      This  is	a  rule  variable that tells CMake how to create a shared library for the
	      language <LANG>.

       CMAKE_<LANG>_CREATE_SHARED_MODULE
	      Rule variable to create a shared module.

	      This is a rule variable that tells CMake how to create a	shared	library  for  the
	      language <LANG>.

       CMAKE_<LANG>_CREATE_STATIC_LIBRARY
	      Rule variable to create a static library.

	      This  is	a  rule  variable that tells CMake how to create a static library for the
	      language <LANG>.

       CMAKE_<LANG>_FLAGS_DEBUG
	      Flags for Debug build type or configuration.

	      <LANG> flags used when CMAKE_BUILD_TYPE is Debug.

       CMAKE_<LANG>_FLAGS_MINSIZEREL
	      Flags for MinSizeRel build type or configuration.

	      <LANG> flags used  when  CMAKE_BUILD_TYPE  is  MinSizeRel.Short  for  minimum  size
	      release.

       CMAKE_<LANG>_FLAGS_RELEASE
	      Flags for Release build type or configuration.

	      <LANG> flags used when CMAKE_BUILD_TYPE is Release

       CMAKE_<LANG>_FLAGS_RELWITHDEBINFO
	      Flags for RelWithDebInfo type or configuration.

	      <LANG>  flags  used when CMAKE_BUILD_TYPE is RelWithDebInfo. Short for Release With
	      Debug Information.

       CMAKE_<LANG>_IGNORE_EXTENSIONS
	      File extensions that should be ignored by the build.

	      This is a list of file extensions that may be part of a project for  a  given  lan-
	      guage but are not compiled.

       CMAKE_<LANG>_IMPLICIT_INCLUDE_DIRECTORIES
	      Directories implicitly searched by the compiler for header files.

	      CMake  does  not explicitly specify these directories on compiler command lines for
	      language <LANG>.	This prevents system include directories from  being  treated  as
	      user include directories on some compilers.

       CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES
	      Implicit linker search path detected for language <LANG>.

	      Compilers  typically  pass  directories  containing  language runtime libraries and
	      default library search paths when they invoke a linker.  These paths  are  implicit
	      linker search directories for the compiler's language.  CMake automatically detects
	      these directories for each language and reports the results in this variable.

	      When a library in  one  of  these  directories  is  given  by  full  path  to  tar-
	      get_link_libraries()  CMake will generate the -l<name> form on link lines to ensure
	      the linker searches its implicit directories  for  the  library.	 Note  that  some
	      toolchains   read  implicit  directories	from  an  environment  variable  such  as
	      LIBRARY_PATH so keep its value consistent when operating in a given build tree.

       CMAKE_<LANG>_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES
	      Implicit linker framework search path detected for language <LANG>.

	      These paths are implicit linker framework search	directories  for  the  compiler's
	      language.   CMake  automatically	detects  these	directories for each language and
	      reports the results in this variable.

       CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES
	      Implicit link libraries and flags detected for language <LANG>.

	      Compilers typically pass language runtime library names and other flags  when  they
	      invoke  a  linker.   These  flags are implicit link options for the compiler's lan-
	      guage.  CMake automatically detects these libraries and flags for each language and
	      reports the results in this variable.

       CMAKE_<LANG>_LIBRARY_ARCHITECTURE
	      Target architecture library directory name detected for <lang>.

	      If the <lang> compiler passes to the linker an architecture-specific system library
	      search directory such as <prefix>/lib/<arch> this variable contains the <arch> name
	      if/as detected by CMake.

       CMAKE_<LANG>_LINKER_PREFERENCE
	      Preference value for linker language selection.

	      The  "linker  language"  for  executable, shared library, and module targets is the
	      language whose compiler will invoke the linker.  The LINKER_LANGUAGE  target  prop-
	      erty  sets  the  language explicitly.  Otherwise, the linker language is that whose
	      linker preference value is highest among languages compiled  and	linked	into  the
	      target.  See also the CMAKE_<LANG>_LINKER_PREFERENCE_PROPAGATES variable.

       CMAKE_<LANG>_LINKER_PREFERENCE_PROPAGATES
	      True if CMAKE_<LANG>_LINKER_PREFERENCE propagates across targets.

	      This is used when CMake selects a linker language for a target.  Languages compiled
	      directly into the target are always considered.  A language  compiled  into  static
	      libraries linked by the target is considered if this variable is true.

       CMAKE_<LANG>_LINK_EXECUTABLE
	      Rule variable to link and executable.

	      Rule variable to link and executable for the given language.

       CMAKE_<LANG>_OUTPUT_EXTENSION
	      Extension for the output of a compile for a single file.

	      This is the extension for an object file for the given <LANG>. For example .obj for
	      C on Windows.

       CMAKE_<LANG>_PLATFORM_ID
	      An internal variable subject to change.

	      This is used in determining the platform and is subject to change.

       CMAKE_<LANG>_SIZEOF_DATA_PTR
	      Size of pointer-to-data types for language <LANG>.

	      This holds the size (in bytes) of pointer-to-data types in the target platform ABI.
	      It is defined for languages C and CXX (C++).

       CMAKE_<LANG>_SOURCE_FILE_EXTENSIONS
	      Extensions of source files for the given language.

	      This is the list of extensions for a given languages source files.

       CMAKE_COMPILER_IS_GNU<LANG>
	      True if the compiler is GNU.

	      If the selected <LANG> compiler is the GNU compiler then this is TRUE, if not it is
	      FALSE. Unlike the other per-language variables, this uses the GNU syntax for  iden-
	      tifying languages instead of the CMake syntax. Recognized values of the <LANG> suf-
	      fix are:

		CC = C compiler
		CXX = C++ compiler
		G77 = Fortran compiler

       CMAKE_Fortran_MODDIR_DEFAULT
	      Fortran default module output directory.

	      Most Fortran compilers write .mod files to  the  current	working  directory.   For
	      those  that  do  not, this is set to "." and used when the Fortran_MODULE_DIRECTORY
	      target property is not set.

       CMAKE_Fortran_MODDIR_FLAG
	      Fortran flag for module output directory.

	      This stores the flag needed to pass the value of the Fortran_MODULE_DIRECTORY  tar-
	      get property to the compiler.

       CMAKE_Fortran_MODOUT_FLAG
	      Fortran flag to enable module output.

	      Most  Fortran  compilers	write .mod files out by default.  For others, this stores
	      the flag needed to enable module output.

       CMAKE_INTERNAL_PLATFORM_ABI
	      An internal variable subject to change.

	      This is used in determining the compiler ABI and is subject to change.

       CMAKE_USER_MAKE_RULES_OVERRIDE_<LANG>
	      Specify a CMake file that overrides platform information for <LANG>.

	      This is a language-specific version of CMAKE_USER_MAKE_RULES_OVERRIDE  loaded  only
	      when enabling language <LANG>.

COPYRIGHT
       Copyright 2000-2012 Kitware, Inc., Insight Software Consortium.	All rights reserved.

       Redistribution  and use in source and binary forms, with or without modification, are per-
       mitted provided that the following conditions are met:

       Redistributions of source code must retain the above copyright notice, this list of condi-
       tions and the following disclaimer.

       Redistributions	in  binary  form  must reproduce the above copyright notice, this list of
       conditions and the following disclaimer in the documentation and/or other  materials  pro-
       vided with the distribution.

       Neither	the  names  of	Kitware,  Inc., the Insight Software Consortium, nor the names of
       their contributors may be used to endorse or promote products derived from  this  software
       without specific prior written permission.

       THIS  SOFTWARE  IS  PROVIDED  BY  THE  COPYRIGHT  HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
       EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE  IMPLIED  WARRANTIES  OF
       MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
       COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,  SPECIAL,
       EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTI-
       TUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS  INTERRUPTION)  HOWEVER
       CAUSED  AND  ON	ANY  THEORY  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
       (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF  THIS	SOFTWARE,
       EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

SEE ALSO
       The following resources are available to get help using CMake:

       Home Page
	      http://www.cmake.org

	      The primary starting point for learning about CMake.

       Frequently Asked Questions
	      http://www.cmake.org/Wiki/CMake_FAQ

	      A Wiki is provided containing answers to frequently asked questions.

       Online Documentation
	      http://www.cmake.org/HTML/Documentation.html

	      Links to available documentation may be found on this web page.

       Mailing List
	      http://www.cmake.org/HTML/MailingLists.html

	      For  help  and  discussion  about  using	cmake,	a  mailing  list  is  provided at
	      cmake@cmake.org. The list is member-post-only but one may sign up on the CMake  web
	      page. Please first read the full documentation at http://www.cmake.org before post-
	      ing questions to the list.

cmake 2.8.11				  June 10, 2014 			     cmakevars(1)
Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums


All times are GMT -4. The time now is 12:28 AM.

Unix & Linux Forums Content Copyright©1993-2018. All Rights Reserved.
×
UNIX.COM Login
Username:
Password:  
Show Password





Not a Forum Member?
Forgot Password?