cpack man page on Alpinelinux

Man page or keyword search:  
man Server   18016 pages
apropos Keyword Search (all sections)
Output format
Alpinelinux logo
[printable version]

cpack(1)							      cpack(1)

NAME
	 cpack - Packaging driver provided by CMake.

USAGE
	 cpack -G <generator> [options]

DESCRIPTION
       The "cpack" executable is the CMake packaging program.  CMake-generated
       build trees created for projects that use the INSTALL_*	commands  have
       packaging support.  This program will generate the package.

       CMake  is  a  cross-platform  build system generator.  Projects specify
       their build process with platform-independent CMake listfiles  included
       in  each directory of a source tree with the name CMakeLists.txt. Users
       build a project by using CMake to generate a build system for a	native
       tool on their platform.

OPTIONS
       -G <generator>
	      Use the specified generator to generate package.

	      CPack  may  support multiple native packaging systems on certain
	      platforms. A generator is responsible for generating input files
	      for particular system and invoking that systems. Possible gener‐
	      ator names are specified in the Generators section.

       -C <Configuration>
	      Specify the project configuration

	      This option specifies the configuration  that  the  project  was
	      build with, for example 'Debug', 'Release'.

       -D <var>=<value>
	      Set a CPack variable.

	      Set a variable that can be used by the generator.

       --config <config file>
	      Specify the config file.

	      Specify the config file to use to create the package. By default
	      CPackConfig.cmake in the current directory will be used.

       --verbose,-V
	      enable verbose output

	      Run cpack with verbose output.

       --debug
	      enable debug output (for CPack developers)

	      Run cpack with debug output (for CPack developers).

       -P <package name>
	      override/define CPACK_PACKAGE_NAME

	      If the package name is not  specified  on	 cpack	commmand  line
	      thenCPack.cmake defines it as CMAKE_PROJECT_NAME

       -R <package version>
	      override/define CPACK_PACKAGE_VERSION

	      If  version  is  not  specified  on  cpack  command  line thenC‐
	      Pack.cmake     defines	  it	  from	    CPACK_PACKAGE_VER‐
	      SION_[MAJOR|MINOR|PATCH]look into CPack.cmake for detail

       -B <package directory>
	      override/define CPACK_PACKAGE_DIRECTORY

	      The  directory  where CPack will be doing its packaging work.The
	      resulting package will be found there. Inside  this  directoryC‐
	      Pack  creates  '_CPack_Packages' sub-directory which is theCPack
	      temporary directory.

       --vendor <vendor name>
	      override/define CPACK_PACKAGE_VENDOR

	      If vendor is not specified on  cpack  command  line  (or	inside
	      CMakeLists.txt) thenCPack.cmake defines it with a default value

       --help-command cmd [file]
	      Print help for a single command and exit.

	      Full  documentation  specific to the given command is displayed.
	      If a file is specified, the documentation is  written  into  and
	      the  output  format is determined depending on the filename suf‐
	      fix. Supported are man page, HTML, DocBook and plain text.

       --help-command-list [file]
	      List available commands and exit.

	      The list contains all commands for which help may be obtained by
	      using the --help-command argument followed by a command name. If
	      a file is specified, the documentation is written into  and  the
	      output  format  is  determined depending on the filename suffix.
	      Supported are man page, HTML, DocBook and plain text.

       --help-commands [file]
	      Print help for all commands and exit.

	      Full documentation specific for  all  current  command  is  dis‐
	      played.If a file is specified, the documentation is written into
	      and the output format is determined depending  on	 the  filename
	      suffix. Supported are man page, HTML, DocBook and plain text.

       --help-variable var [file]
	      Print help for a single variable and exit.

	      Full  documentation  specific  to	 the  given  variable  is dis‐
	      played.If a file is specified, the documentation is written into
	      and  the	output	format is determined depending on the filename
	      suffix. Supported are man page, HTML, DocBook and plain text.

       --help-variable-list [file]
	      List documented variables and exit.

	      The list contains all variables for which help may  be  obtained
	      by  using	 the  --help-variable  argument followed by a variable
	      name.  If a file is specified, the help is written into it.If  a
	      file  is	specified,  the	 documentation is written into and the
	      output format is determined depending on	the  filename  suffix.
	      Supported are man page, HTML, DocBook and plain text.

       --help-variables [file]
	      Print help for all variables and exit.

	      Full  documentation  for all variables is displayed.If a file is
	      specified, the documentation is written into and the output for‐
	      mat  is  determined  depending on the filename suffix. Supported
	      are man page, HTML, DocBook and plain text.

       --copyright [file]
	      Print the CMake copyright and exit.

	      If a file is specified, the copyright is written into it.

       --help,-help,-usage,-h,-H,/?
	      Print usage information and exit.

	      Usage  describes	the  basic  command  line  interface  and  its
	      options.

       --help-full [file]
	      Print full help and exit.

	      Full  help  displays  most  of the documentation provided by the
	      UNIX man page.  It is provided for use  on  non-UNIX  platforms,
	      but  is  also convenient if the man page is not installed.  If a
	      file is specified, the help is written into it.

       --help-html [file]
	      Print full help in HTML format.

	      This option is used by CMake authors to help produce web	pages.
	      If a file is specified, the help is written into it.

       --help-man [file]
	      Print full help as a UNIX man page and exit.

	      This  option is used by the cmake build to generate the UNIX man
	      page.  If a file is specified, the help is written into it.

       --version,-version,/V [file]
	      Show program name/version banner and exit.

	      If a file is specified, the version is written into it.

GENERATORS
       DEB    Debian packages

       NSIS   Null Soft Installer

       NSIS64 Null Soft Installer (64-bit)

       RPM    RPM packages

       STGZ   Self extracting Tar GZip compression

       TBZ2   Tar BZip2 compression

       TGZ    Tar GZip compression

       TZ     Tar Compress compression

       ZIP    ZIP file format

COMMANDS
       cpack_add_component
	      Describes a CPack installation component named by the  COMPONENT
	      argument to a CMake INSTALL command.

		cpack_add_component(compname
				    [DISPLAY_NAME name]
				    [DESCRIPTION description]
				    [HIDDEN | REQUIRED | DISABLED ]
				    [GROUP group]
				    [DEPENDS comp1 comp2 ... ]
				    [INSTALL_TYPES type1 type2 ... ]
				    [DOWNLOADED]
				    [ARCHIVE_FILE filename])

	      The cmake_add_component command describes an installation compo‐
	      nent, which the user can opt to install or remove as part of the
	      graphical installation process. compname is the name of the com‐
	      ponent, as provided to the COMPONENT argument  of	 one  or  more
	      CMake INSTALL commands.

	      DISPLAY_NAME  is	the  displayed	name of the component, used in
	      graphical installers to display the component name.  This	 value
	      can be any string.

	      DESCRIPTION is an extended description of the component, used in
	      graphical installers to give  the	 user  additional  information
	      about  the component. Descriptions can span multiple lines using
	      "\n" as the line separator. Typically, these descriptions should
	      be no more than a few lines long.

	      HIDDEN  indicates	 that  this  component	will  be hidden in the
	      graphical installer, so that the	user  cannot  directly	change
	      whether it is installed or not.

	      REQUIRED	indicates  that this component is required, and there‐
	      fore will always be installed. It will be visible in the graphi‐
	      cal installer, but it cannot be unselected. (Typically, required
	      components are shown greyed out).

	      DISABLED indicates that this component should be disabled (unse‐
	      lected)  by  default.  The user is free to select this component
	      for installation, unless it is also HIDDEN.

	      DEPENDS lists the components on which this component depends. If
	      this  component  is selected, then each of the components listed
	      must also be selected. The  dependency  information  is  encoded
	      within the installer itself, so that users cannot install incon‐
	      sistent sets of components.

	      GROUP names the component group of which	this  component	 is  a
	      part. If not provided, the component will be a standalone compo‐
	      nent, not part of any  component	group.	Component  groups  are
	      described	 with  the cpack_add_component_group command, detailed
	      below.

	      INSTALL_TYPES lists the installation types of which this	compo‐
	      nent  is	a  part.  When	one  of	 these	installations types is
	      selected, this component will automatically be selected. Instal‐
	      lation  types are described with the cpack_add_install_type com‐
	      mand, detailed below.

	      DOWNLOADED indicates that this component	should	be  downloaded
	      on-the-fly  by  the  installer, rather than packaged in with the
	      installer itself. For more information,  see  the	 cpack_config‐
	      ure_downloads command.

	      ARCHIVE_FILE  provides  a	 name  for the archive file created by
	      CPack to be used for downloaded  components.  If	not  supplied,
	      CPack  will  create  a  file with some name based on CPACK_PACK‐
	      AGE_FILE_NAME and the name of the component.  See	 cpack_config‐
	      ure_downloads for more information.

       cpack_add_component_group
	      Describes a group of related CPack installation components.

		cpack_add_component_group(groupname
					 [DISPLAY_NAME name]
					 [DESCRIPTION description]
					 [PARENT_GROUP parent]
					 [EXPANDED]
					 [BOLD_TITLE])

	      The  cpack_add_component_group describes a group of installation
	      components, which will be placed together within the listing  of
	      options.	 Typically,   component	  groups  allow	 the  user  to
	      select/deselect all of the components within a single group  via
	      a	 single group-level option. Use component groups to reduce the
	      complexity of installers with  many  options.  groupname	is  an
	      arbitrary	 name used to identify the group in the GROUP argument
	      of the cpack_add_component command, which is  used  to  place  a
	      component	 in  a	group. The name of the group must not conflict
	      with the name of any component.

	      DISPLAY_NAME is the displayed name of the component group,  used
	      in  graphical  installers	 to  display the component group name.
	      This value can be any string.

	      DESCRIPTION is an extended description of the  component	group,
	      used  in graphical installers to give the user additional infor‐
	      mation about the components within that group. Descriptions  can
	      span multiple lines using "\n" as the line separator. Typically,
	      these descriptions should be no more than a few lines long.

	      PARENT_GROUP, if supplied, names the parent group of this group.
	      Parent  groups are used to establish a hierarchy of groups, pro‐
	      viding an arbitrary hierarchy of groups.

	      EXPANDED indicates that, by default, the group should show up as
	      "expanded",  so that the user immediately sees all of the compo‐
	      nents within the group. Otherwise, the group will initially show
	      up as a single entry.

	      BOLD_TITLE indicates that the group title should appear in bold,
	      to call the user's attention to the group.

       cpack_add_install_type
	      Add a new installation type containing a set of predefined  com‐
	      ponent selections to the graphical installer.

		cpack_add_install_type(typename
				       [DISPLAY_NAME name])

	      The  cpack_add_install_type  command  identifies a set of prese‐
	      lected components that represents	 a  common  use	 case  for  an
	      application.  For	 example,  a  "Developer"  install  type might
	      include an application along with its header and library	files,
	      while an "End user" install type might just include the applica‐
	      tion's executable. Each component identifies itself with one  or
	      more   install   types   via   the   INSTALL_TYPES  argument  to
	      cpack_add_component.

	      DISPLAY_NAME is the displayed name of the	 install  type,	 which
	      will typically show up in a drop-down box within a graphical in‐
	      staller. This value can be any string.

       cpack_configure_downloads
	      Configure CPack to download selected  components	on-the-fly  as
	      part of the installation process.

		cpack_configure_downloads(site
					  [UPLOAD_DIRECTORY dirname]
					  [ALL]
					  [ADD_REMOVE|NO_ADD_REMOVE])

	      The   cpack_configure_downloads	command	 configures  installa‐
	      tion-time downloads of selected components. For  each  download‐
	      able component, CPack will create an archive containing the con‐
	      tents of that component, which should be uploaded to  the	 given
	      site. When the user selects that component for installation, the
	      installer will download and extract the component in place. This
	      feature  is useful for creating small installers that only down‐
	      load the requested components, saving  bandwidth.	 Additionally,
	      the  installers  are small enough that they will be installed as
	      part of the normal installation process, and the "Change" button
	      in  Windows  Add/Remove Programs control panel will allow one to
	      add or remove  parts  of	the  application  after	 the  original
	      installation.  On Windows, the downloaded-components functional‐
	      ity requires the ZipDLL plug-in for NSIS, available at:

		http://nsis.sourceforge.net/ZipDLL_plug-in

	      On Mac OS X, installers that download components on-the-fly  can
	      only  be	built  and  installed on system using Mac OS X 10.5 or
	      later.

	      The site argument is a URL where the archives  for  downloadable
	      components	     will	      reside,		 e.g.,
	      http://www.cmake.org/files/2.6.1/installer/ All of the  archives
	      produced by CPack should be uploaded to that location.

	      UPLOAD_DIRECTORY	is the local directory where CPack will create
	      the various archives for each of the components. The contents of
	      this  directory  should  be uploaded to a location accessible by
	      the URL given in the site argument. If omitted, CPack  will  use
	      the  directory CPackUploads inside the CMake binary directory to
	      store the generated archives.

	      The ALL flag indicates that all components be downloaded. Other‐
	      wise,  only  those components explicitly marked as DOWNLOADED or
	      that have a specified ARCHIVE_FILE will be downloaded. Addition‐
	      ally, the ALL option implies ADD_REMOVE (unless NO_ADD_REMOVE is
	      specified).

	      ADD_REMOVE indicates that CPack should install a copy of the in‐
	      staller  that  can  be  called from Windows' Add/Remove Programs
	      dialog (via the "Modify" button) to change the set of  installed
	      components.  NO_ADD_REMOVE  turns off this behavior. This option
	      is ignored on Mac OS X.

       break  Break from an enclosing foreach or while loop.

		break()

	      Breaks from an enclosing foreach loop or while loop

       cmake_host_system_information
	      Query host system specific information.

		cmake_host_system_information(RESULT <variable> QUERY <key> ...)

	      Queries system information of the host  system  on  which	 cmake
	      runs.  One  or more <key> can be provided to select the informa‐
	      tion to be queried. The list of  queried	values	is  stored  in
	      <variable>.

	      <key> can be one of the following values:

		NUMBER_OF_LOGICAL_CORES	  = Number of logical cores.
		NUMBER_OF_PHYSICAL_CORES  = Number of physical cores.
		HOSTNAME		  = Hostname.
		FQDN			  = Fully qualified domain name.
		TOTAL_VIRTUAL_MEMORY	  = Total virtual memory in megabytes.
		AVAILABLE_VIRTUAL_MEMORY  = Available virtual memory in megabytes.
		TOTAL_PHYSICAL_MEMORY	  = Total physical memory in megabytes.
		AVAILABLE_PHYSICAL_MEMORY = Available physical memory in megabytes.

       cmake_minimum_required
	      Set the minimum required version of cmake for a project.

		cmake_minimum_required(VERSION major[.minor[.patch[.tweak]]]
				       [FATAL_ERROR])

	      If  the  current version of CMake is lower than that required it
	      will stop processing the project and report an  error.   When  a
	      version  higher  than  2.4  is  specified the command implicitly
	      invokes

		cmake_policy(VERSION major[.minor[.patch[.tweak]]])

	      which sets the cmake policy version level to the version	speci‐
	      fied.  When version 2.4 or lower is given the command implicitly
	      invokes

		cmake_policy(VERSION 2.4)

	      which enables compatibility features for CMake 2.4 and lower.

	      The FATAL_ERROR option is accepted but ignored by CMake 2.6  and
	      higher.	It should be specified so CMake versions 2.4 and lower
	      fail with an error instead of just a warning.

       cmake_policy
	      Manage CMake Policy settings.

	      As CMake evolves it is sometimes necessary  to  change  existing
	      behavior	in  order  to  fix  bugs or improve implementations of
	      existing features.  The CMake Policy mechanism  is  designed  to
	      help  keep  existing  projects building as new versions of CMake
	      introduce changes in  behavior.	Each  new  policy  (behavioral
	      change)  is  given  an  identifier of the form "CMP<NNNN>" where
	      "<NNNN>" is an integer  index.   Documentation  associated  with
	      each  policy  describes  the OLD and NEW behavior and the reason
	      the policy was introduced.  Projects  may	 set  each  policy  to
	      select  the  desired  behavior.	When CMake needs to know which
	      behavior to use  it  checks  for	a  setting  specified  by  the
	      project.	If no setting is available the OLD behavior is assumed
	      and a warning is produced requesting that the policy be set.

	      The cmake_policy command is used to set policies to OLD  or  NEW
	      behavior.	  While setting policies individually is supported, we
	      encourage projects to set policies based on CMake versions.

		cmake_policy(VERSION major.minor[.patch[.tweak]])

	      Specify that the current CMake list  file	 is  written  for  the
	      given  version  of CMake.	 All policies introduced in the speci‐
	      fied version or earlier will be set to use  NEW  behavior.   All
	      policies	introduced  after  the specified version will be unset
	      (unless variable CMAKE_POLICY_DEFAULT_CMP<NNNN> sets a default).
	      This effectively requests behavior preferred as of a given CMake
	      version and tells newer CMake versions to warn about  their  new
	      policies.	  The policy version specified must be at least 2.4 or
	      the command will report an error.	 In order to get compatibility
	      features	supporting versions earlier than 2.4 see documentation
	      of policy CMP0001.

		cmake_policy(SET CMP<NNNN> NEW)
		cmake_policy(SET CMP<NNNN> OLD)

	      Tell CMake to use the OLD or NEW behavior for  a	given  policy.
	      Projects	depending  on  the  old behavior of a given policy may
	      silence a policy warning by setting the  policy  state  to  OLD.
	      Alternatively  one  may  fix  the	 project  to work with the new
	      behavior and set the policy state to NEW.

		cmake_policy(GET CMP<NNNN> <variable>)

	      Check whether a given policy is set to OLD or NEW behavior.  The
	      output  variable	value  will be "OLD" or "NEW" if the policy is
	      set, and empty otherwise.

	      CMake keeps policy settings on a stack, so changes made  by  the
	      cmake_policy  command  affect  only the top of the stack.	 A new
	      entry on the policy stack is managed automatically for each sub‐
	      directory	 to protect its parents and siblings.  CMake also man‐
	      ages a new entry for scripts loaded by include() and  find_pack‐
	      age()  commands  except  when  invoked  with the NO_POLICY_SCOPE
	      option (see also policy CMP0011).	 The cmake_policy command pro‐
	      vides an interface to manage custom entries on the policy stack:

		cmake_policy(PUSH)
		cmake_policy(POP)

	      Each  PUSH  must have a matching POP to erase any changes.  This
	      is useful to make temporary changes to policy settings.

	      Functions and macros record policy settings when they  are  cre‐
	      ated  and use the pre-record policies when they are invoked.  If
	      the function or macro implementation sets policies, the  changes
	      automatically  propagate up through callers until they reach the
	      closest nested policy stack entry.

       configure_file
	      Copy a file to another location and modify its contents.

		configure_file(<input> <output>
			       [COPYONLY] [ESCAPE_QUOTES] [@ONLY]
			       [NEWLINE_STYLE [UNIX|DOS|WIN32|LF|CRLF] ])

	      Copies a file <input> to file <output> and substitutes  variable
	      values referenced in the file content.  If <input> is a relative
	      path it is evaluated with respect to the current	source	direc‐
	      tory.  The <input> must be a file, not a directory.  If <output>
	      is a relative path it is evaluated with respect to  the  current
	      binary  directory.   If <output> names an existing directory the
	      input file is placed in that directory with its original name.

	      If the <input> file is modified the  build  system  will	re-run
	      CMake  to	 re-configure  the  file and generate the build system
	      again.

	      This command replaces any variables in the input file referenced
	      as ${VAR} or @VAR@ with their values as determined by CMake.  If
	      a variable is not defined, it will be replaced with nothing.  If
	      COPYONLY	is  specified,	then  no  variable expansion will take
	      place.  If  ESCAPE_QUOTES	 is  specified	then  any  substituted
	      quotes  will  be	C-style	 escaped.  The file will be configured
	      with the current values of CMake variables. If @ONLY  is	speci‐
	      fied,  only  variables  of  the  form @VAR@ will be replaced and
	      ${VAR} will be ignored.  This is useful for configuring  scripts
	      that use ${VAR}.

	      Input  file  lines  of  the  form "#cmakedefine VAR ..." will be
	      replaced with either "#define VAR ..." or	 "/*  #undef  VAR  */"
	      depending	 on  whether VAR is set in CMake to any value not con‐
	      sidered a false constant by the if() command. (Content of "...",
	      if  any,	is  processed  as above.) Input file lines of the form
	      "#cmakedefine01 VAR" will be replaced with either	 "#define  VAR
	      1" or "#define VAR 0" similarly.

	      With NEWLINE_STYLE the line ending could be adjusted:

		  'UNIX' or 'LF' for \n, 'DOS', 'WIN32' or 'CRLF' for \r\n.

	      COPYONLY must not be used with NEWLINE_STYLE.

       else   Starts the else portion of an if block.

		else(expression)

	      See the if command.

       elseif Starts the elseif portion of an if block.

		elseif(expression)

	      See the if command.

       endforeach
	      Ends a list of commands in a FOREACH block.

		endforeach(expression)

	      See the FOREACH command.

       endfunction
	      Ends a list of commands in a function block.

		endfunction(expression)

	      See the function command.

       endif  Ends a list of commands in an if block.

		endif(expression)

	      See the if command.

       endmacro
	      Ends a list of commands in a macro block.

		endmacro(expression)

	      See the macro command.

       endwhile
	      Ends a list of commands in a while block.

		endwhile(expression)

	      See the while command.

       execute_process
	      Execute one or more child processes.

		execute_process(COMMAND <cmd1> [args1...]]
				[COMMAND <cmd2> [args2...] [...]]
				[WORKING_DIRECTORY <directory>]
				[TIMEOUT <seconds>]
				[RESULT_VARIABLE <variable>]
				[OUTPUT_VARIABLE <variable>]
				[ERROR_VARIABLE <variable>]
				[INPUT_FILE <file>]
				[OUTPUT_FILE <file>]
				[ERROR_FILE <file>]
				[OUTPUT_QUIET]
				[ERROR_QUIET]
				[OUTPUT_STRIP_TRAILING_WHITESPACE]
				[ERROR_STRIP_TRAILING_WHITESPACE])

	      Runs  the	 given sequence of one or more commands with the stan‐
	      dard output of each process piped to the standard input  of  the
	      next.   A	 single standard error pipe is used for all processes.
	      If WORKING_DIRECTORY is given the named directory will be set as
	      the  current working directory of the child processes.  If TIME‐
	      OUT is given the child processes will be terminated if  they  do
	      not  finish  in  the  specified number of seconds (fractions are
	      allowed).	 If RESULT_VARIABLE is given the variable will be  set
	      to contain the result of running the processes.  This will be an
	      integer return code from the last child or a  string  describing
	      an  error	 condition.   If OUTPUT_VARIABLE or ERROR_VARIABLE are
	      given the variable named will be set with the  contents  of  the
	      standard	output	and standard error pipes respectively.	If the
	      same variable is named for  both	pipes  their  output  will  be
	      merged  in  the  order produced.	If INPUT_FILE, OUTPUT_FILE, or
	      ERROR_FILE is given the file named will be attached to the stan‐
	      dard  input  of  the  first process, standard output of the last
	      process, or standard error of all	 processes  respectively.   If
	      OUTPUT_QUIET or ERROR_QUIET is given then the standard output or
	      standard error results will be quietly ignored.	If  more  than
	      one  OUTPUT_*  or	 ERROR_* option is given for the same pipe the
	      precedence is not specified.  If no OUTPUT_* or ERROR_*  options
	      are given the output will be shared with the corresponding pipes
	      of the CMake process itself.

	      The execute_process command is a newer more powerful version  of
	      exec_program,  but the old command has been kept for compatibil‐
	      ity.

       file   File manipulation command.

		file(WRITE filename "message to write"... )
		file(APPEND filename "message to write"... )
		file(READ filename variable [LIMIT numBytes] [OFFSET offset] [HEX])
		file(<MD5|SHA1|SHA224|SHA256|SHA384|SHA512> filename variable)
		file(STRINGS filename variable [LIMIT_COUNT num]
		     [LIMIT_INPUT numBytes] [LIMIT_OUTPUT numBytes]
		     [LENGTH_MINIMUM numBytes] [LENGTH_MAXIMUM numBytes]
		     [NEWLINE_CONSUME] [REGEX regex]
		     [NO_HEX_CONVERSION])
		file(GLOB variable [RELATIVE path] [globbing expressions]...)
		file(GLOB_RECURSE variable [RELATIVE path]
		     [FOLLOW_SYMLINKS] [globbing expressions]...)
		file(RENAME <oldname> <newname>)
		file(REMOVE [file1 ...])
		file(REMOVE_RECURSE [file1 ...])
		file(MAKE_DIRECTORY [directory1 directory2 ...])
		file(RELATIVE_PATH variable directory file)
		file(TO_CMAKE_PATH path result)
		file(TO_NATIVE_PATH path result)
		file(DOWNLOAD url file [INACTIVITY_TIMEOUT timeout]
		     [TIMEOUT timeout] [STATUS status] [LOG log] [SHOW_PROGRESS]
		     [EXPECTED_HASH ALGO=value] [EXPECTED_MD5 sum]
		     [TLS_VERIFY on|off] [TLS_CAINFO file])
		file(UPLOAD filename url [INACTIVITY_TIMEOUT timeout]
		     [TIMEOUT timeout] [STATUS status] [LOG log] [SHOW_PROGRESS])
		file(TIMESTAMP filename variable [<format string>] [UTC])
		file(GENERATE OUTPUT output_file
		     <INPUT input_file|CONTENT input_content>
		     [CONDITION expression])

	      WRITE will write a message into a	 file  called  'filename'.  It
	      overwrites  the  file if it already exists, and creates the file
	      if it does not exist. (If the file is a build input, use config‐
	      ure_file to update the file only when its content changes.)

	      APPEND will write a message into a file same as WRITE, except it
	      will append it to the end of the file

	      READ will read the content of a file and store it into the vari‐
	      able. It will start at the given offset and read up to numBytes.
	      If the argument HEX is given, the binary data will be  converted
	      to  hexadecimal  representation  and  this will be stored in the
	      variable.

	      MD5, SHA1, SHA224, SHA256, SHA384, and  SHA512  will  compute  a
	      cryptographic hash of the content of a file.

	      STRINGS will parse a list of ASCII strings from a file and store
	      it in a variable. Binary data in the file are ignored.  Carriage
	      return  (CR) characters are ignored. It works also for Intel Hex
	      and Motorola S-record files, which are  automatically  converted
	      to   binary   format  when  reading  them.  Disable  this	 using
	      NO_HEX_CONVERSION.

	      LIMIT_COUNT sets	the  maximum  number  of  strings  to  return.
	      LIMIT_INPUT  sets	 the  maximum number of bytes to read from the
	      input file. LIMIT_OUTPUT sets the maximum	 number	 of  bytes  to
	      store  in	 the  output variable. LENGTH_MINIMUM sets the minimum
	      length of a string  to  return.  Shorter	strings	 are  ignored.
	      LENGTH_MAXIMUM  sets  the	 maximum length of a string to return.
	      Longer strings are split into strings no longer than the maximum
	      length.  NEWLINE_CONSUME	allows	newlines  to  be  included  in
	      strings instead of terminating them.

	      REGEX specifies a regular expression that a string must match to
	      be returned. Typical usage

		file(STRINGS myfile.txt myfile)

	      stores  a	 list in the variable "myfile" in which each item is a
	      line from the input file.

	      GLOB will generate a list of all files that match	 the  globbing
	      expressions and store it into the variable. Globbing expressions
	      are similar to regular expressions, but much simpler.  If	 RELA‐
	      TIVE  flag  is  specified for an expression, the results will be
	      returned as a relative path to the given path.  (We do not  rec‐
	      ommend  using  GLOB  to collect a list of source files from your
	      source tree.  If no CMakeLists.txt file changes when a source is
	      added  or	 removed  then	the generated build system cannot know
	      when to ask CMake to regenerate.)

	      Examples of globbing expressions include:

		 *.cxx	    - match all files with extension cxx
		 *.vt?	    - match all files with extension vta,...,vtz
		 f[3-5].txt - match files f3.txt, f4.txt, f5.txt

	      GLOB_RECURSE will generate a list similar to the	regular	 GLOB,
	      except  it  will	traverse all the subdirectories of the matched
	      directory and match the files. Subdirectories that are  symlinks
	      are  only	 traversed if FOLLOW_SYMLINKS is given or cmake policy
	      CMP0009 is not set to NEW. See cmake --help-policy  CMP0009  for
	      more information.

	      Examples of recursive globbing include:

		 /dir/*.py  - match all python files in /dir and subdirectories

	      MAKE_DIRECTORY  will create the given directories, also if their
	      parent directories don't exist yet

	      RENAME moves a file or directory within a filesystem,  replacing
	      the destination atomically.

	      REMOVE will remove the given files, also in subdirectories

	      REMOVE_RECURSE will remove the given files and directories, also
	      non-empty directories

	      RELATIVE_PATH will determine relative path from directory to the
	      given file.

	      TO_CMAKE_PATH  will  convert  path  into a cmake style path with
	      unix /.  The input can be a single path or a  system  path  like
	      "$ENV{PATH}".   Note  the	 double	 quotes	 around	 the  ENV call
	      TO_CMAKE_PATH only takes	one argument. This command  will  also
	      convert  the native list delimiters for a list of paths like the
	      PATH environment variable.

	      TO_NATIVE_PATH works just like TO_CMAKE_PATH, but	 will  convert
	      from   a	cmake style path into the native path style \ for win‐
	      dows and / for UNIX.

	      DOWNLOAD will download the given URL to the given file.  If  LOG
	      var  is  specified  a log of the download will be put in var. If
	      STATUS var is specified the status of the operation will be  put
	      in  var. The status is returned in a list of length 2. The first
	      element is the numeric return value for the operation,  and  the
	      second  element  is  a  string  value for the error. A 0 numeric
	      error means no error in the operation. If TIMEOUT time is speci‐
	      fied, the operation will timeout after time seconds, time should
	      be specified as an integer. The INACTIVITY_TIMEOUT specifies  an
	      integer  number  of seconds of inactivity after which the opera‐
	      tion should terminate. If EXPECTED_HASH ALGO=value is specified,
	      the operation will verify that the downloaded file's actual hash
	      matches the expected value, where ALGO  is  one  of  MD5,	 SHA1,
	      SHA224,  SHA256,	SHA384,	 or SHA512.  If it does not match, the
	      operation fails with an error. ("EXPECTED_MD5 sum" is short-hand
	      for  "EXPECTED_HASH  MD5=sum".)  If  SHOW_PROGRESS is specified,
	      progress information will be printed as  status  messages	 until
	      the  operation  is  complete. For https URLs CMake must be built
	      with OpenSSL.  TLS/SSL certificates are not checked by  default.
	      Set   TLS_VERIFY	 to   ON  to  check  certificates  and/or  use
	      EXPECTED_HASH to verify downloaded content.  Set	TLS_CAINFO  to
	      specify  a  custom  Certificate  Authority  file.	 If either TLS
	      option is not given CMake will check variables  CMAKE_TLS_VERIFY
	      and CMAKE_TLS_CAINFO, respectively.

	      UPLOAD  will  upload the given file to the given URL. If LOG var
	      is specified a log of the upload will be put in var.  If	STATUS
	      var is specified the status of the operation will be put in var.
	      The status is returned in a list of length 2. The first  element
	      is  the  numeric	return value for the operation, and the second
	      element is a string value for the error. A 0 numeric error means
	      no  error	 in  the  operation. If TIMEOUT time is specified, the
	      operation will timeout after time seconds, time should be speci‐
	      fied  as an integer. The INACTIVITY_TIMEOUT specifies an integer
	      number of seconds of inactivity after which the operation should
	      terminate.  If  SHOW_PROGRESS is specified, progress information
	      will be printed as status messages until the operation  is  com‐
	      plete.

	      TIMESTAMP will write a string representation of the modification
	      time of filename to variable.

	      Should the command be unable to obtain a timestamp variable will
	      be set to the empty string "".

	      See  documentation  of the string TIMESTAMP sub-command for more
	      details.

	      The file() command also provides COPY and INSTALL signatures:

		file(<COPY|INSTALL> files... DESTINATION <dir>
		     [FILE_PERMISSIONS permissions...]
		     [DIRECTORY_PERMISSIONS permissions...]
		     [NO_SOURCE_PERMISSIONS] [USE_SOURCE_PERMISSIONS]
		     [FILES_MATCHING]
		     [[PATTERN <pattern> | REGEX <regex>]
		      [EXCLUDE] [PERMISSIONS permissions...]] [...])

	      The COPY signature copies files, directories, and symlinks to  a
	      destination  folder.   Relative  input  paths are evaluated with
	      respect to the current source directory, and a relative destina‐
	      tion  is	evaluated with respect to the current build directory.
	      Copying preserves input file timestamps,	and  optimizes	out  a
	      file  if	it  exists at the destination with the same timestamp.
	      Copying preserves input permissions unless explicit  permissions
	      or  NO_SOURCE_PERMISSIONS	 are given (default is USE_SOURCE_PER‐
	      MISSIONS).  See the install(DIRECTORY) command for documentation
	      of permissions, PATTERN, REGEX, and EXCLUDE options.

	      The INSTALL signature differs slightly from COPY: it prints sta‐
	      tus messages, and NO_SOURCE_PERMISSIONS is  default.   Installa‐
	      tion  scripts generated by the install() command use this signa‐
	      ture (with some undocumented options for internal use).

	      GENERATE will  write  an	<output_file>  with  content  from  an
	      <input_file>,  or from <input_content>.  The output is generated
	      conditionally based on the content of the <condition>.  The file
	      is written at CMake generate-time and the input may contain gen‐
	      erator  expressions.    The   <condition>,   <output_file>   and
	      <input_file>  may also contain generator expressions.  The <con‐
	      dition> must evaluate to either '0' or '1'.   The	 <output_file>
	      must  evaluate  to  a  unique  name among all configurations and
	      among all invocations of file(GENERATE).

       find_file
	      Find the full path to a file.

		 find_file(<VAR> name1 [path1 path2 ...])

	      This is the short-hand signature for the command that is	suffi‐
	      cient  in	 many  cases.  It is the same as find_file(<VAR> name1
	      [PATHS path1 path2 ...])

		 find_file(
			   <VAR>
			   name | NAMES name1 [name2 ...]
			   [HINTS path1 [path2 ... ENV var]]
			   [PATHS path1 [path2 ... ENV var]]
			   [PATH_SUFFIXES suffix1 [suffix2 ...]]
			   [DOC "cache documentation string"]
			   [NO_DEFAULT_PATH]
			   [NO_CMAKE_ENVIRONMENT_PATH]
			   [NO_CMAKE_PATH]
			   [NO_SYSTEM_ENVIRONMENT_PATH]
			   [NO_CMAKE_SYSTEM_PATH]
			   [CMAKE_FIND_ROOT_PATH_BOTH |
			    ONLY_CMAKE_FIND_ROOT_PATH |
			    NO_CMAKE_FIND_ROOT_PATH]
			  )

	      This command is used to find a full path to named file. A	 cache
	      entry named by <VAR> is created to store the result of this com‐
	      mand.  If the full path to a file is found the result is	stored
	      in  the  variable and the search will not be repeated unless the
	      variable is cleared.  If nothing is found, the  result  will  be
	      <VAR>-NOTFOUND,  and the search will be attempted again the next
	      time find_file is invoked with the same variable.	 The  name  of
	      the full path to a file that is searched for is specified by the
	      names listed after the NAMES argument.   Additional search loca‐
	      tions  can be specified after the PATHS argument.	 If ENV var is
	      found in the HINTS or PATHS section the environment variable var
	      will be read and converted from a system environment variable to
	      a cmake style list of paths.  For example ENV PATH  would	 be  a
	      way  to  list  the  system path variable. The argument after DOC
	      will  be	used  for  the	documentation  string  in  the	cache.
	      PATH_SUFFIXES specifies additional subdirectories to check below
	      each search path.

	      If NO_DEFAULT_PATH is specified, then no	additional  paths  are
	      added  to	 the  search. If NO_DEFAULT_PATH is not specified, the
	      search process is as follows:

	      1. Search paths specified	 in  cmake-specific  cache  variables.
	      These  are  intended  to	be  used  on  the  command line with a
	      -DVAR=value.  This can be skipped if NO_CMAKE_PATH is passed.

		 <prefix>/include/<arch> if CMAKE_LIBRARY_ARCHITECTURE is set, and
		 <prefix>/include for each <prefix> in CMAKE_PREFIX_PATH
		 CMAKE_INCLUDE_PATH
		 CMAKE_FRAMEWORK_PATH

	      2. Search paths specified in  cmake-specific  environment	 vari‐
	      ables.  These are intended to be set in the user's shell config‐
	      uration.	This can be skipped  if	 NO_CMAKE_ENVIRONMENT_PATH  is
	      passed.

		 <prefix>/include/<arch> if CMAKE_LIBRARY_ARCHITECTURE is set, and
		 <prefix>/include for each <prefix> in CMAKE_PREFIX_PATH
		 CMAKE_INCLUDE_PATH
		 CMAKE_FRAMEWORK_PATH

	      3. Search the paths specified by the HINTS option.  These should
	      be paths computed by system introspection, such as a  hint  pro‐
	      vided by the location of another item already found.  Hard-coded
	      guesses should be specified with the PATHS option.

	      4. Search the standard system environment variables. This can be
	      skipped if NO_SYSTEM_ENVIRONMENT_PATH is an argument.

		 PATH
		 INCLUDE

	      5.  Search cmake variables defined in the Platform files for the
	      current system.  This can be skipped if NO_CMAKE_SYSTEM_PATH  is
	      passed.

		 <prefix>/include/<arch> if CMAKE_LIBRARY_ARCHITECTURE is set, and
		 <prefix>/include for each <prefix> in CMAKE_SYSTEM_PREFIX_PATH
		 CMAKE_SYSTEM_INCLUDE_PATH
		 CMAKE_SYSTEM_FRAMEWORK_PATH

	      6.  Search  the  paths  specified	 by the PATHS option or in the
	      short-hand  version  of  the  command.   These   are   typically
	      hard-coded guesses.

	      On Darwin or systems supporting OS X Frameworks, the cmake vari‐
	      able    CMAKE_FIND_FRAMEWORK can be set to empty or one  of  the
	      following:

		 "FIRST"  - Try to find frameworks before standard
			    libraries or headers. This is the default on Darwin.
		 "LAST"	  - Try to find frameworks after standard
			    libraries or headers.
		 "ONLY"	  - Only try to find frameworks.
		 "NEVER" - Never try to find frameworks.

	      On  Darwin  or  systems supporting OS X Application Bundles, the
	      cmake variable CMAKE_FIND_APPBUNDLE can be set to empty  or  one
	      of the following:

		 "FIRST"  - Try to find application bundles before standard
			    programs. This is the default on Darwin.
		 "LAST"	  - Try to find application bundles after standard
			    programs.
		 "ONLY"	  - Only try to find application bundles.
		 "NEVER" - Never try to find application bundles.

	      The  CMake  variable  CMAKE_FIND_ROOT_PATH specifies one or more
	      directories to be prepended to  all  other  search  directories.
	      This  effectively "re-roots" the entire search under given loca‐
	      tions. By default it is empty.  It  is  especially  useful  when
	      cross-compiling  to  point  to  the root directory of the target
	      environment and CMake will search there too. By default at first
	      the  directories	listed	in  CMAKE_FIND_ROOT_PATH  and then the
	      non-rooted directories will be searched.	The  default  behavior
	      can  be  adjusted	 by setting CMAKE_FIND_ROOT_PATH_MODE_INCLUDE.
	      This behavior can be manually overridden on a per-call basis. By
	      using  CMAKE_FIND_ROOT_PATH_BOTH	the  search  order  will be as
	      described	 above.	 If  NO_CMAKE_FIND_ROOT_PATH  is   used	  then
	      CMAKE_FIND_ROOT_PATH	will	  not	   be	  used.	    If
	      ONLY_CMAKE_FIND_ROOT_PATH is used then only the re-rooted direc‐
	      tories will be searched.

	      The  default  search  order  is  designed to be most-specific to
	      least-specific for common use cases.  Projects may override  the
	      order by simply calling the command multiple times and using the
	      NO_* options:

		 find_file(<VAR> NAMES name PATHS paths... NO_DEFAULT_PATH)
		 find_file(<VAR> NAMES name)

	      Once one of the calls succeeds the result variable will  be  set
	      and stored in the cache so that no call will search again.

       find_library
	      Find a library.

		 find_library(<VAR> name1 [path1 path2 ...])

	      This  is the short-hand signature for the command that is suffi‐
	      cient in many cases.  It is the same as find_library(<VAR> name1
	      [PATHS path1 path2 ...])

		 find_library(
			   <VAR>
			   name | NAMES name1 [name2 ...] [NAMES_PER_DIR]
			   [HINTS path1 [path2 ... ENV var]]
			   [PATHS path1 [path2 ... ENV var]]
			   [PATH_SUFFIXES suffix1 [suffix2 ...]]
			   [DOC "cache documentation string"]
			   [NO_DEFAULT_PATH]
			   [NO_CMAKE_ENVIRONMENT_PATH]
			   [NO_CMAKE_PATH]
			   [NO_SYSTEM_ENVIRONMENT_PATH]
			   [NO_CMAKE_SYSTEM_PATH]
			   [CMAKE_FIND_ROOT_PATH_BOTH |
			    ONLY_CMAKE_FIND_ROOT_PATH |
			    NO_CMAKE_FIND_ROOT_PATH]
			  )

	      This  command  is used to find a library. A cache entry named by
	      <VAR> is created to store the result of this  command.   If  the
	      library  is  found  the result is stored in the variable and the
	      search will not be repeated unless the variable is cleared.   If
	      nothing  is  found,  the	result will be <VAR>-NOTFOUND, and the
	      search will be attempted again the  next	time  find_library  is
	      invoked with the same variable.  The name of the library that is
	      searched for is specified by the names listed  after  the	 NAMES
	      argument.	   Additional  search locations can be specified after
	      the PATHS argument.  If ENV var is found in the HINTS  or	 PATHS
	      section  the environment variable var will be read and converted
	      from a system environment variable to  a	cmake  style  list  of
	      paths.   For  example ENV PATH would be a way to list the system
	      path variable. The argument after DOC will be used for the docu‐
	      mentation	 string	 in  the cache.	 PATH_SUFFIXES specifies addi‐
	      tional subdirectories to check below each search path.

	      If NO_DEFAULT_PATH is specified, then no	additional  paths  are
	      added  to	 the  search. If NO_DEFAULT_PATH is not specified, the
	      search process is as follows:

	      1. Search paths specified	 in  cmake-specific  cache  variables.
	      These  are  intended  to	be  used  on  the  command line with a
	      -DVAR=value.  This can be skipped if NO_CMAKE_PATH is passed.

		 <prefix>/lib/<arch> if CMAKE_LIBRARY_ARCHITECTURE is set, and
		 <prefix>/lib for each <prefix> in CMAKE_PREFIX_PATH
		 CMAKE_LIBRARY_PATH
		 CMAKE_FRAMEWORK_PATH

	      2. Search paths specified in  cmake-specific  environment	 vari‐
	      ables.  These are intended to be set in the user's shell config‐
	      uration.	This can be skipped  if	 NO_CMAKE_ENVIRONMENT_PATH  is
	      passed.

		 <prefix>/lib/<arch> if CMAKE_LIBRARY_ARCHITECTURE is set, and
		 <prefix>/lib for each <prefix> in CMAKE_PREFIX_PATH
		 CMAKE_LIBRARY_PATH
		 CMAKE_FRAMEWORK_PATH

	      3. Search the paths specified by the HINTS option.  These should
	      be paths computed by system introspection, such as a  hint  pro‐
	      vided by the location of another item already found.  Hard-coded
	      guesses should be specified with the PATHS option.

	      4. Search the standard system environment variables. This can be
	      skipped if NO_SYSTEM_ENVIRONMENT_PATH is an argument.

		 PATH
		 LIB

	      5.  Search cmake variables defined in the Platform files for the
	      current system.  This can be skipped if NO_CMAKE_SYSTEM_PATH  is
	      passed.

		 <prefix>/lib/<arch> if CMAKE_LIBRARY_ARCHITECTURE is set, and
		 <prefix>/lib for each <prefix> in CMAKE_SYSTEM_PREFIX_PATH
		 CMAKE_SYSTEM_LIBRARY_PATH
		 CMAKE_SYSTEM_FRAMEWORK_PATH

	      6.  Search  the  paths  specified	 by the PATHS option or in the
	      short-hand  version  of  the  command.   These   are   typically
	      hard-coded guesses.

	      On Darwin or systems supporting OS X Frameworks, the cmake vari‐
	      able    CMAKE_FIND_FRAMEWORK can be set to empty or one  of  the
	      following:

		 "FIRST"  - Try to find frameworks before standard
			    libraries or headers. This is the default on Darwin.
		 "LAST"	  - Try to find frameworks after standard
			    libraries or headers.
		 "ONLY"	  - Only try to find frameworks.
		 "NEVER" - Never try to find frameworks.

	      On  Darwin  or  systems supporting OS X Application Bundles, the
	      cmake variable CMAKE_FIND_APPBUNDLE can be set to empty  or  one
	      of the following:

		 "FIRST"  - Try to find application bundles before standard
			    programs. This is the default on Darwin.
		 "LAST"	  - Try to find application bundles after standard
			    programs.
		 "ONLY"	  - Only try to find application bundles.
		 "NEVER" - Never try to find application bundles.

	      The  CMake  variable  CMAKE_FIND_ROOT_PATH specifies one or more
	      directories to be prepended to  all  other  search  directories.
	      This  effectively "re-roots" the entire search under given loca‐
	      tions. By default it is empty.  It  is  especially  useful  when
	      cross-compiling  to  point  to  the root directory of the target
	      environment and CMake will search there too. By default at first
	      the  directories	listed	in  CMAKE_FIND_ROOT_PATH  and then the
	      non-rooted directories will be searched.	The  default  behavior
	      can  be  adjusted	 by setting CMAKE_FIND_ROOT_PATH_MODE_LIBRARY.
	      This behavior can be manually overridden on a per-call basis. By
	      using  CMAKE_FIND_ROOT_PATH_BOTH	the  search  order  will be as
	      described	 above.	 If  NO_CMAKE_FIND_ROOT_PATH  is   used	  then
	      CMAKE_FIND_ROOT_PATH	will	  not	   be	  used.	    If
	      ONLY_CMAKE_FIND_ROOT_PATH is used then only the re-rooted direc‐
	      tories will be searched.

	      The  default  search  order  is  designed to be most-specific to
	      least-specific for common use cases.  Projects may override  the
	      order by simply calling the command multiple times and using the
	      NO_* options:

		 find_library(<VAR> NAMES name PATHS paths... NO_DEFAULT_PATH)
		 find_library(<VAR> NAMES name)

	      Once one of the calls succeeds the result variable will  be  set
	      and stored in the cache so that no call will search again.

	      When  more than one value is given to the NAMES option this com‐
	      mand by default will consider one name  at  a  time  and	search
	      every  directory	for  it.   The NAMES_PER_DIR option tells this
	      command to consider one directory at a time and search  for  all
	      names in it.

	      If the library found is a framework, then VAR will be set to the
	      full path to the framework <fullPath>/A.framework. When  a  full
	      path  to	a  framework  is  used	as a library, CMake will use a
	      -framework A, and a -F<fullPath> to link the  framework  to  the
	      target.

	      If  the  global property FIND_LIBRARY_USE_LIB64_PATHS is set all
	      search paths will be tested as normal, with "64/" appended,  and
	      with all matches of "lib/" replaced with "lib64/". This property
	      is automatically set for the platforms that are known to need it
	      if  at  least one of the languages supported by the PROJECT com‐
	      mand is enabled.

       find_package
	      Load settings for an external project.

		find_package(<package> [version] [EXACT] [QUIET] [MODULE]
			     [REQUIRED] [[COMPONENTS] [components...]]
			     [OPTIONAL_COMPONENTS components...]
			     [NO_POLICY_SCOPE])

	      Finds and loads  settings	 from  an  external  project.	<pack‐
	      age>_FOUND  will	be  set	 to  indicate  whether the package was
	      found.  When the package is found	 package-specific  information
	      is provided through variables and imported targets documented by
	      the package itself.  The QUIET option disables messages  if  the
	      package  cannot be found.	 The MODULE option disables the second
	      signature documented below.  The REQUIRED option stops  process‐
	      ing with an error message if the package cannot be found.

	      A	 package-specific  list	 of  required components may be listed
	      after the COMPONENTS option (or after  the  REQUIRED  option  if
	      present).	  Additional  optional	components may be listed after
	      OPTIONAL_COMPONENTS.  Available components and  their  influence
	      on  whether  a  package is considered to be found are defined by
	      the target package.

	      The [version] argument requests a version with which the package
	      found	  should       be      compatible      (format	    is
	      major[.minor[.patch[.tweak]]]).  The EXACT option requests  that
	      the  version  be matched exactly.	 If no [version] and/or compo‐
	      nent list is given to a recursive invocation inside a  find-mod‐
	      ule,  the	 corresponding	arguments  are forwarded automatically
	      from the outer call (including the EXACT	flag  for  [version]).
	      Version support is currently provided only on a package-by-pack‐
	      age basis (details below).

	      User code should generally look for  packages  using  the	 above
	      simple  signature.   The remainder of this command documentation
	      specifies the full command signature and details of  the	search
	      process.	Project maintainers wishing to provide a package to be
	      found by this command are encouraged to read on.

	      The command has two modes by which  it  searches	for  packages:
	      "Module"	mode and "Config" mode.	 Module mode is available when
	      the command is invoked with the above reduced signature.	 CMake
	      searches	 for   a  file	called	"Find<package>.cmake"  in  the
	      CMAKE_MODULE_PATH followed by the CMake  installation.   If  the
	      file is found, it is read and processed by CMake.	 It is respon‐
	      sible for finding the package, checking the version, and produc‐
	      ing  any	needed messages.  Many find-modules provide limited or
	      no support for versioning; check the module  documentation.   If
	      no  module  is found and the MODULE option is not given the com‐
	      mand proceeds to Config mode.

	      The complete Config mode command signature is:

		find_package(<package> [version] [EXACT] [QUIET]
			     [REQUIRED] [[COMPONENTS] [components...]]
			     [CONFIG|NO_MODULE]
			     [NO_POLICY_SCOPE]
			     [NAMES name1 [name2 ...]]
			     [CONFIGS config1 [config2 ...]]
			     [HINTS path1 [path2 ... ]]
			     [PATHS path1 [path2 ... ]]
			     [PATH_SUFFIXES suffix1 [suffix2 ...]]
			     [NO_DEFAULT_PATH]
			     [NO_CMAKE_ENVIRONMENT_PATH]
			     [NO_CMAKE_PATH]
			     [NO_SYSTEM_ENVIRONMENT_PATH]
			     [NO_CMAKE_PACKAGE_REGISTRY]
			     [NO_CMAKE_BUILDS_PATH]
			     [NO_CMAKE_SYSTEM_PATH]
			     [NO_CMAKE_SYSTEM_PACKAGE_REGISTRY]
			     [CMAKE_FIND_ROOT_PATH_BOTH |
			      ONLY_CMAKE_FIND_ROOT_PATH |
			      NO_CMAKE_FIND_ROOT_PATH])

	      The CONFIG option may be used to skip Module mode explicitly and
	      switch  to  Config  mode.	  It is synonymous to using NO_MODULE.
	      Config mode is also implied by use of options not	 specified  in
	      the reduced signature.

	      Config  mode attempts to locate a configuration file provided by
	      the package to be found.	A cache entry called <package>_DIR  is
	      created  to  hold the directory containing the file.  By default
	      the command searches for a package with the name <package>.   If
	      the  NAMES  option  is  given  the  names	 following it are used
	      instead of <package>.  The command searches for  a  file	called
	      "<name>Config.cmake"   or	 "<lower-case-name>-config.cmake"  for
	      each name specified.  A replacement set of  possible  configura‐
	      tion  file  names	 may  be  given using the CONFIGS option.  The
	      search procedure is specified below.  Once found, the configura‐
	      tion  file  is  read  and processed by CMake.  Since the file is
	      provided by the package it already knows the location of package
	      contents.	  The full path to the configuration file is stored in
	      the cmake variable <package>_CONFIG.

	      All configuration files which  have  been	 considered  by	 CMake
	      while  searching	for  an	 installation  of  the package with an
	      appropriate version are stored  in  the  cmake  variable	<pack‐
	      age>_CONSIDERED_CONFIGS,	 the  associated  versions  in	<pack‐
	      age>_CONSIDERED_VERSIONS.

	      If the package configuration file cannot	be  found  CMake  will
	      generate	an error describing the problem unless the QUIET argu‐
	      ment is specified.  If REQUIRED is specified and the package  is
	      not  found  a  fatal  error  is generated and the configure step
	      stops executing.	If <package>_DIR has been set to  a  directory
	      not  containing  a  configuration	 file CMake will ignore it and
	      search from scratch.

	      When the [version] argument is given Config mode will only  find
	      a	 version  of  the  package  that claims compatibility with the
	      requested version (format is major[.minor[.patch[.tweak]]]).  If
	      the EXACT option is given only a version of the package claiming
	      an exact match of the requested version  may  be	found.	 CMake
	      does  not	 establish  any	 convention for the meaning of version
	      numbers.	Package version numbers are checked by "version" files
	      provided	by  the	 packages themselves.  For a candidate package
	      configuration file "<config-file>.cmake" the corresponding  ver‐
	      sion  file  is  located  next  to	 it  and  named	 either "<con‐
	      fig-file>-version.cmake" or "<config-file>Version.cmake".	 If no
	      such  version  file  is available then the configuration file is
	      assumed to not be compatible  with  any  requested  version.   A
	      basic  version file containing generic version matching code can
	      be created using the  macro  write_basic_package_version_file(),
	      see  its documentation for more details.	When a version file is
	      found it is loaded to check the requested version	 number.   The
	      version  file is loaded in a nested scope in which the following
	      variables have been defined:

		PACKAGE_FIND_NAME	   = the <package> name
		PACKAGE_FIND_VERSION	   = full requested version string
		PACKAGE_FIND_VERSION_MAJOR = major version if requested, else 0
		PACKAGE_FIND_VERSION_MINOR = minor version if requested, else 0
		PACKAGE_FIND_VERSION_PATCH = patch version if requested, else 0
		PACKAGE_FIND_VERSION_TWEAK = tweak version if requested, else 0
		PACKAGE_FIND_VERSION_COUNT = number of version components, 0 to 4

	      The version file checks whether it satisfies the requested  ver‐
	      sion and sets these variables:

		PACKAGE_VERSION		   = full provided version string
		PACKAGE_VERSION_EXACT	   = true if version is exact match
		PACKAGE_VERSION_COMPATIBLE = true if version is compatible
		PACKAGE_VERSION_UNSUITABLE = true if unsuitable as any version

	      These  variables	are  checked  by  the  find_package command to
	      determine whether the configuration file provides an  acceptable
	      version.	 They  are  not	 available after the find_package call
	      returns.	If the version is acceptable the  following  variables
	      are set:

		<package>_VERSION	= full provided version string
		<package>_VERSION_MAJOR = major version if provided, else 0
		<package>_VERSION_MINOR = minor version if provided, else 0
		<package>_VERSION_PATCH = patch version if provided, else 0
		<package>_VERSION_TWEAK = tweak version if provided, else 0
		<package>_VERSION_COUNT = number of version components, 0 to 4

	      and  the	corresponding  package	configuration  file is loaded.
	      When multiple package configuration files	 are  available	 whose
	      version  files claim compatibility with the version requested it
	      is unspecified which one is  chosen.   No	 attempt  is  made  to
	      choose a highest or closest version number.

	      Config  mode  provides  an elaborate interface and search proce‐
	      dure.  Much of the interface is provided	for  completeness  and
	      for  use internally by find-modules loaded by Module mode.  Most
	      user code should simply call

		find_package(<package> [major[.minor]] [EXACT] [REQUIRED|QUIET])

	      in order to find a package.  Package maintainers providing CMake
	      package  configuration  files are encouraged to name and install
	      them such that the procedure outlined below will find them with‐
	      out requiring use of additional options.

	      CMake constructs a set of possible installation prefixes for the
	      package.	Under each prefix several directories are searched for
	      a	 configuration	file.	The  tables below show the directories
	      searched.	 Each entry is meant for installation trees  following
	      Windows (W), UNIX (U), or Apple (A) conventions.

		<prefix>/						(W)
		<prefix>/(cmake|CMake)/					(W)
		<prefix>/<name>*/					(W)
		<prefix>/<name>*/(cmake|CMake)/				(W)
		<prefix>/(lib/<arch>|lib|share)/cmake/<name>*/		(U)
		<prefix>/(lib/<arch>|lib|share)/<name>*/		(U)
		<prefix>/(lib/<arch>|lib|share)/<name>*/(cmake|CMake)/	(U)

	      On  systems  supporting  OS X Frameworks and Application Bundles
	      the following directories are searched for frameworks or bundles
	      containing a configuration file:

		<prefix>/<name>.framework/Resources/			(A)
		<prefix>/<name>.framework/Resources/CMake/		(A)
		<prefix>/<name>.framework/Versions/*/Resources/		(A)
		<prefix>/<name>.framework/Versions/*/Resources/CMake/	(A)
		<prefix>/<name>.app/Contents/Resources/			(A)
		<prefix>/<name>.app/Contents/Resources/CMake/		(A)

	      In  all cases the <name> is treated as case-insensitive and cor‐
	      responds to any of the names specified (<package> or names given
	      by    NAMES).	Paths	with   lib/<arch>   are	  enabled   if
	      CMAKE_LIBRARY_ARCHITECTURE is set.  If PATH_SUFFIXES  is	speci‐
	      fied  the	 suffixes  are	appended  to each (W) or (U) directory
	      entry one-by-one.

	      This set of directories is intended to work in cooperation  with
	      projects	that provide configuration files in their installation
	      trees.  Directories above	 marked	 with  (W)  are	 intended  for
	      installations  on	 Windows where the prefix may point at the top
	      of an application's installation directory.  Those  marked  with
	      (U)  are	intended for installations on UNIX platforms where the
	      prefix is shared by multiple packages.  This is merely a conven‐
	      tion,  so	 all (W) and (U) directories are still searched on all
	      platforms.  Directories marked with (A) are intended for instal‐
	      lations	 on    Apple	platforms.     The   cmake   variables
	      CMAKE_FIND_FRAMEWORK  and	 CMAKE_FIND_APPBUNDLE  determine   the
	      order of preference as specified below.

	      The  set	of installation prefixes is constructed using the fol‐
	      lowing steps.  If NO_DEFAULT_PATH is specified all NO_*  options
	      are enabled.

	      1.  Search  paths	 specified  in cmake-specific cache variables.
	      These are intended to  be	 used  on  the	command	 line  with  a
	      -DVAR=value.  This can be skipped if NO_CMAKE_PATH is passed.

		 CMAKE_PREFIX_PATH
		 CMAKE_FRAMEWORK_PATH
		 CMAKE_APPBUNDLE_PATH

	      2.  Search  paths	 specified in cmake-specific environment vari‐
	      ables.  These are intended to be set in the user's shell config‐
	      uration.	 This  can  be skipped if NO_CMAKE_ENVIRONMENT_PATH is
	      passed.

		 <package>_DIR
		 CMAKE_PREFIX_PATH
		 CMAKE_FRAMEWORK_PATH
		 CMAKE_APPBUNDLE_PATH

	      3. Search paths specified by the HINTS option.  These should  be
	      paths  computed by system introspection, such as a hint provided
	      by the location  of  another  item  already  found.   Hard-coded
	      guesses should be specified with the PATHS option.

	      4. Search the standard system environment variables. This can be
	      skipped if NO_SYSTEM_ENVIRONMENT_PATH is passed.	 Path  entries
	      ending in "/bin" or "/sbin" are automatically converted to their
	      parent directories.

		 PATH

	      5. Search project build trees recently  configured  in  a	 CMake
	      GUI.  This can be skipped if NO_CMAKE_BUILDS_PATH is passed.  It
	      is intended for the case when a user is building multiple depen‐
	      dent projects one after another.

	      6. Search paths stored in the CMake user package registry.  This
	      can be skipped if NO_CMAKE_PACKAGE_REGISTRY is passed.  On  Win‐
	      dows a <package> may appear under registry key

		HKEY_CURRENT_USER\Software\Kitware\CMake\Packages\<package>

	      as  a  REG_SZ  value,  with  arbitrary  name, that specifies the
	      directory containing the package configuration  file.   On  UNIX
	      platforms a <package> may appear under the directory

		~/.cmake/packages/<package>

	      as  a  file,  with  arbitrary  name, whose content specifies the
	      directory containing the package configuration  file.   See  the
	      export(PACKAGE)  command to create user package registry entries
	      for project build trees.

	      7. Search cmake variables defined in the Platform files for  the
	      current  system.	This can be skipped if NO_CMAKE_SYSTEM_PATH is
	      passed.

		 CMAKE_SYSTEM_PREFIX_PATH
		 CMAKE_SYSTEM_FRAMEWORK_PATH
		 CMAKE_SYSTEM_APPBUNDLE_PATH

	      8. Search paths stored in the  CMake  system  package  registry.
	      This  can	 be  skipped  if  NO_CMAKE_SYSTEM_PACKAGE_REGISTRY  is
	      passed.  On Windows a <package> may appear under registry key

		HKEY_LOCAL_MACHINE\Software\Kitware\CMake\Packages\<package>

	      as a REG_SZ value,  with	arbitrary  name,  that	specifies  the
	      directory	 containing  the package configuration file.  There is
	      no system package registry on non-Windows platforms.

	      9. Search paths specified by the PATHS option.  These are	 typi‐
	      cally hard-coded guesses.

	      On Darwin or systems supporting OS X Frameworks, the cmake vari‐
	      able    CMAKE_FIND_FRAMEWORK can be set to empty or one  of  the
	      following:

		 "FIRST"  - Try to find frameworks before standard
			    libraries or headers. This is the default on Darwin.
		 "LAST"	  - Try to find frameworks after standard
			    libraries or headers.
		 "ONLY"	  - Only try to find frameworks.
		 "NEVER" - Never try to find frameworks.

	      On  Darwin  or  systems supporting OS X Application Bundles, the
	      cmake variable CMAKE_FIND_APPBUNDLE can be set to empty  or  one
	      of the following:

		 "FIRST"  - Try to find application bundles before standard
			    programs. This is the default on Darwin.
		 "LAST"	  - Try to find application bundles after standard
			    programs.
		 "ONLY"	  - Only try to find application bundles.
		 "NEVER" - Never try to find application bundles.

	      The  CMake  variable  CMAKE_FIND_ROOT_PATH specifies one or more
	      directories to be prepended to  all  other  search  directories.
	      This  effectively "re-roots" the entire search under given loca‐
	      tions. By default it is empty.  It  is  especially  useful  when
	      cross-compiling  to  point  to  the root directory of the target
	      environment and CMake will search there too. By default at first
	      the  directories	listed	in  CMAKE_FIND_ROOT_PATH  and then the
	      non-rooted directories will be searched.	The  default  behavior
	      can  be  adjusted	 by setting CMAKE_FIND_ROOT_PATH_MODE_PACKAGE.
	      This behavior can be manually overridden on a per-call basis. By
	      using  CMAKE_FIND_ROOT_PATH_BOTH	the  search  order  will be as
	      described	 above.	 If  NO_CMAKE_FIND_ROOT_PATH  is   used	  then
	      CMAKE_FIND_ROOT_PATH	will	  not	   be	  used.	    If
	      ONLY_CMAKE_FIND_ROOT_PATH is used then only the re-rooted direc‐
	      tories will be searched.

	      The  default  search  order  is  designed to be most-specific to
	      least-specific for common use cases.  Projects may override  the
	      order by simply calling the command multiple times and using the
	      NO_* options:

		 find_package(<package> PATHS paths... NO_DEFAULT_PATH)
		 find_package(<package>)

	      Once one of the calls succeeds the result variable will  be  set
	      and stored in the cache so that no call will search again.

	      Every  non-REQUIRED  find_package() call can be disabled by set‐
	      ting the variable CMAKE_DISABLE_FIND_PACKAGE_<package> to	 TRUE.
	      See  the documentation for the CMAKE_DISABLE_FIND_PACKAGE_<pack‐
	      age> variable for more information.

	      When  loading  a	find  module  or  package  configuration  file
	      find_package  defines variables to provide information about the
	      call arguments (and restores their original state before return‐
	      ing):

	       <package>_FIND_REQUIRED	    = true if REQUIRED option was given
	       <package>_FIND_QUIETLY	    = true if QUIET option was given
	       <package>_FIND_VERSION	    = full requested version string
	       <package>_FIND_VERSION_MAJOR = major version if requested, else 0
	       <package>_FIND_VERSION_MINOR = minor version if requested, else 0
	       <package>_FIND_VERSION_PATCH = patch version if requested, else 0
	       <package>_FIND_VERSION_TWEAK = tweak version if requested, else 0
	       <package>_FIND_VERSION_COUNT = number of version components, 0 to 4
	       <package>_FIND_VERSION_EXACT = true if EXACT option was given
	       <package>_FIND_COMPONENTS    = list of requested components
	       <package>_FIND_REQUIRED_<c>  = true if component <c> is required
					      false if component <c> is optional

	      In  Module  mode	the loaded find module is responsible to honor
	      the request detailed by these variables; see the find module for
	      details.	 In  Config mode find_package handles REQUIRED, QUIET,
	      and version options automatically but leaves it to  the  package
	      configuration  file  to  handle  components  in a way that makes
	      sense for the package.  The package configuration file  may  set
	      <package>_FOUND  to  false  to  tell find_package that component
	      requirements are not satisfied.

	      See the cmake_policy() command documentation for	discussion  of
	      the NO_POLICY_SCOPE option.

       find_path
	      Find the directory containing a file.

		 find_path(<VAR> name1 [path1 path2 ...])

	      This  is the short-hand signature for the command that is suffi‐
	      cient in many cases.  It is the same  as	find_path(<VAR>	 name1
	      [PATHS path1 path2 ...])

		 find_path(
			   <VAR>
			   name | NAMES name1 [name2 ...]
			   [HINTS path1 [path2 ... ENV var]]
			   [PATHS path1 [path2 ... ENV var]]
			   [PATH_SUFFIXES suffix1 [suffix2 ...]]
			   [DOC "cache documentation string"]
			   [NO_DEFAULT_PATH]
			   [NO_CMAKE_ENVIRONMENT_PATH]
			   [NO_CMAKE_PATH]
			   [NO_SYSTEM_ENVIRONMENT_PATH]
			   [NO_CMAKE_SYSTEM_PATH]
			   [CMAKE_FIND_ROOT_PATH_BOTH |
			    ONLY_CMAKE_FIND_ROOT_PATH |
			    NO_CMAKE_FIND_ROOT_PATH]
			  )

	      This  command  is	 used to find a directory containing the named
	      file. A cache entry named by  <VAR>  is  created	to  store  the
	      result of this command.  If the file in a directory is found the
	      result is stored in the variable and  the	 search	 will  not  be
	      repeated	unless	the variable is cleared.  If nothing is found,
	      the result will  be  <VAR>-NOTFOUND,  and	 the  search  will  be
	      attempted again the next time find_path is invoked with the same
	      variable.	 The name of the file in a directory that is  searched
	      for  is  specified by the names listed after the NAMES argument.
	      Additional search locations can be  specified  after  the	 PATHS
	      argument.	 If ENV var is found in the HINTS or PATHS section the
	      environment variable var will be read and converted from a  sys‐
	      tem  environment	variable  to a cmake style list of paths.  For
	      example ENV PATH would be a way to list the  system  path	 vari‐
	      able.  The argument after DOC will be used for the documentation
	      string in the cache.  PATH_SUFFIXES specifies additional	subdi‐
	      rectories to check below each search path.

	      If  NO_DEFAULT_PATH  is  specified, then no additional paths are
	      added to the search. If NO_DEFAULT_PATH is  not  specified,  the
	      search process is as follows:

	      1.  Search  paths	 specified  in cmake-specific cache variables.
	      These are intended to  be	 used  on  the	command	 line  with  a
	      -DVAR=value.  This can be skipped if NO_CMAKE_PATH is passed.

		 <prefix>/include/<arch> if CMAKE_LIBRARY_ARCHITECTURE is set, and
		 <prefix>/include for each <prefix> in CMAKE_PREFIX_PATH
		 CMAKE_INCLUDE_PATH
		 CMAKE_FRAMEWORK_PATH

	      2.  Search  paths	 specified in cmake-specific environment vari‐
	      ables.  These are intended to be set in the user's shell config‐
	      uration.	 This  can  be skipped if NO_CMAKE_ENVIRONMENT_PATH is
	      passed.

		 <prefix>/include/<arch> if CMAKE_LIBRARY_ARCHITECTURE is set, and
		 <prefix>/include for each <prefix> in CMAKE_PREFIX_PATH
		 CMAKE_INCLUDE_PATH
		 CMAKE_FRAMEWORK_PATH

	      3. Search the paths specified by the HINTS option.  These should
	      be  paths	 computed by system introspection, such as a hint pro‐
	      vided by the location of another item already found.  Hard-coded
	      guesses should be specified with the PATHS option.

	      4. Search the standard system environment variables. This can be
	      skipped if NO_SYSTEM_ENVIRONMENT_PATH is an argument.

		 PATH
		 INCLUDE

	      5. Search cmake variables defined in the Platform files for  the
	      current  system.	This can be skipped if NO_CMAKE_SYSTEM_PATH is
	      passed.

		 <prefix>/include/<arch> if CMAKE_LIBRARY_ARCHITECTURE is set, and
		 <prefix>/include for each <prefix> in CMAKE_SYSTEM_PREFIX_PATH
		 CMAKE_SYSTEM_INCLUDE_PATH
		 CMAKE_SYSTEM_FRAMEWORK_PATH

	      6. Search the paths specified by the  PATHS  option  or  in  the
	      short-hand   version   of	 the  command.	 These	are  typically
	      hard-coded guesses.

	      On Darwin or systems supporting OS X Frameworks, the cmake vari‐
	      able     CMAKE_FIND_FRAMEWORK  can be set to empty or one of the
	      following:

		 "FIRST"  - Try to find frameworks before standard
			    libraries or headers. This is the default on Darwin.
		 "LAST"	  - Try to find frameworks after standard
			    libraries or headers.
		 "ONLY"	  - Only try to find frameworks.
		 "NEVER" - Never try to find frameworks.

	      On Darwin or systems supporting OS X  Application	 Bundles,  the
	      cmake  variable  CMAKE_FIND_APPBUNDLE can be set to empty or one
	      of the following:

		 "FIRST"  - Try to find application bundles before standard
			    programs. This is the default on Darwin.
		 "LAST"	  - Try to find application bundles after standard
			    programs.
		 "ONLY"	  - Only try to find application bundles.
		 "NEVER" - Never try to find application bundles.

	      The CMake variable CMAKE_FIND_ROOT_PATH specifies	 one  or  more
	      directories  to  be  prepended  to all other search directories.
	      This effectively "re-roots" the entire search under given	 loca‐
	      tions.  By  default  it  is  empty. It is especially useful when
	      cross-compiling to point to the root  directory  of  the	target
	      environment and CMake will search there too. By default at first
	      the directories listed  in  CMAKE_FIND_ROOT_PATH	and  then  the
	      non-rooted  directories  will  be searched. The default behavior
	      can be adjusted  by  setting  CMAKE_FIND_ROOT_PATH_MODE_INCLUDE.
	      This behavior can be manually overridden on a per-call basis. By
	      using CMAKE_FIND_ROOT_PATH_BOTH the  search  order  will	be  as
	      described	  above.   If  NO_CMAKE_FIND_ROOT_PATH	is  used  then
	      CMAKE_FIND_ROOT_PATH     will	not	 be	 used.	    If
	      ONLY_CMAKE_FIND_ROOT_PATH is used then only the re-rooted direc‐
	      tories will be searched.

	      The default search order is  designed  to	 be  most-specific  to
	      least-specific  for common use cases.  Projects may override the
	      order by simply calling the command multiple times and using the
	      NO_* options:

		 find_path(<VAR> NAMES name PATHS paths... NO_DEFAULT_PATH)
		 find_path(<VAR> NAMES name)

	      Once  one	 of the calls succeeds the result variable will be set
	      and stored in the cache so that no call will search again.

	      When searching for frameworks,  if  the  file  is	 specified  as
	      A/b.h, then the framework search will look for A.framework/Head‐
	      ers/b.h. If that is found the path will be set to	 the  path  to
	      the  framework. CMake will convert this to the correct -F option
	      to include the file.

       find_program
	      Find an executable program.

		 find_program(<VAR> name1 [path1 path2 ...])

	      This is the short-hand signature for the command that is	suffi‐
	      cient in many cases.  It is the same as find_program(<VAR> name1
	      [PATHS path1 path2 ...])

		 find_program(
			   <VAR>
			   name | NAMES name1 [name2 ...]
			   [HINTS path1 [path2 ... ENV var]]
			   [PATHS path1 [path2 ... ENV var]]
			   [PATH_SUFFIXES suffix1 [suffix2 ...]]
			   [DOC "cache documentation string"]
			   [NO_DEFAULT_PATH]
			   [NO_CMAKE_ENVIRONMENT_PATH]
			   [NO_CMAKE_PATH]
			   [NO_SYSTEM_ENVIRONMENT_PATH]
			   [NO_CMAKE_SYSTEM_PATH]
			   [CMAKE_FIND_ROOT_PATH_BOTH |
			    ONLY_CMAKE_FIND_ROOT_PATH |
			    NO_CMAKE_FIND_ROOT_PATH]
			  )

	      This command is used to find a program. A cache entry  named  by
	      <VAR>  is	 created  to store the result of this command.	If the
	      program is found the result is stored in the  variable  and  the
	      search  will not be repeated unless the variable is cleared.  If
	      nothing is found, the result will	 be  <VAR>-NOTFOUND,  and  the
	      search  will  be	attempted  again the next time find_program is
	      invoked with the same variable.  The name of the program that is
	      searched	for  is	 specified by the names listed after the NAMES
	      argument.	  Additional search locations can be  specified	 after
	      the  PATHS  argument.  If ENV var is found in the HINTS or PATHS
	      section the environment variable var will be read and  converted
	      from  a  system  environment  variable  to a cmake style list of
	      paths.  For example ENV PATH would be a way to list  the	system
	      path variable. The argument after DOC will be used for the docu‐
	      mentation string in the cache.   PATH_SUFFIXES  specifies	 addi‐
	      tional subdirectories to check below each search path.

	      If  NO_DEFAULT_PATH  is  specified, then no additional paths are
	      added to the search. If NO_DEFAULT_PATH is  not  specified,  the
	      search process is as follows:

	      1.  Search  paths	 specified  in cmake-specific cache variables.
	      These are intended to  be	 used  on  the	command	 line  with  a
	      -DVAR=value.  This can be skipped if NO_CMAKE_PATH is passed.

		 <prefix>/[s]bin for each <prefix> in CMAKE_PREFIX_PATH
		 CMAKE_PROGRAM_PATH
		 CMAKE_APPBUNDLE_PATH

	      2.  Search  paths	 specified in cmake-specific environment vari‐
	      ables.  These are intended to be set in the user's shell config‐
	      uration.	 This  can  be skipped if NO_CMAKE_ENVIRONMENT_PATH is
	      passed.

		 <prefix>/[s]bin for each <prefix> in CMAKE_PREFIX_PATH
		 CMAKE_PROGRAM_PATH
		 CMAKE_APPBUNDLE_PATH

	      3. Search the paths specified by the HINTS option.  These should
	      be  paths	 computed by system introspection, such as a hint pro‐
	      vided by the location of another item already found.  Hard-coded
	      guesses should be specified with the PATHS option.

	      4. Search the standard system environment variables. This can be
	      skipped if NO_SYSTEM_ENVIRONMENT_PATH is an argument.

		 PATH

	      5. Search cmake variables defined in the Platform files for  the
	      current  system.	This can be skipped if NO_CMAKE_SYSTEM_PATH is
	      passed.

		 <prefix>/[s]bin for each <prefix> in CMAKE_SYSTEM_PREFIX_PATH
		 CMAKE_SYSTEM_PROGRAM_PATH
		 CMAKE_SYSTEM_APPBUNDLE_PATH

	      6. Search the paths specified by the  PATHS  option  or  in  the
	      short-hand   version   of	 the  command.	 These	are  typically
	      hard-coded guesses.

	      On Darwin or systems supporting OS X Frameworks, the cmake vari‐
	      able     CMAKE_FIND_FRAMEWORK  can be set to empty or one of the
	      following:

		 "FIRST"  - Try to find frameworks before standard
			    libraries or headers. This is the default on Darwin.
		 "LAST"	  - Try to find frameworks after standard
			    libraries or headers.
		 "ONLY"	  - Only try to find frameworks.
		 "NEVER" - Never try to find frameworks.

	      On Darwin or systems supporting OS X  Application	 Bundles,  the
	      cmake  variable  CMAKE_FIND_APPBUNDLE can be set to empty or one
	      of the following:

		 "FIRST"  - Try to find application bundles before standard
			    programs. This is the default on Darwin.
		 "LAST"	  - Try to find application bundles after standard
			    programs.
		 "ONLY"	  - Only try to find application bundles.
		 "NEVER" - Never try to find application bundles.

	      The CMake variable CMAKE_FIND_ROOT_PATH specifies	 one  or  more
	      directories  to  be  prepended  to all other search directories.
	      This effectively "re-roots" the entire search under given	 loca‐
	      tions.  By  default  it  is  empty. It is especially useful when
	      cross-compiling to point to the root  directory  of  the	target
	      environment and CMake will search there too. By default at first
	      the directories listed  in  CMAKE_FIND_ROOT_PATH	and  then  the
	      non-rooted  directories  will  be searched. The default behavior
	      can be adjusted  by  setting  CMAKE_FIND_ROOT_PATH_MODE_PROGRAM.
	      This behavior can be manually overridden on a per-call basis. By
	      using CMAKE_FIND_ROOT_PATH_BOTH the  search  order  will	be  as
	      described	  above.   If  NO_CMAKE_FIND_ROOT_PATH	is  used  then
	      CMAKE_FIND_ROOT_PATH     will	not	 be	 used.	    If
	      ONLY_CMAKE_FIND_ROOT_PATH is used then only the re-rooted direc‐
	      tories will be searched.

	      The default search order is  designed  to	 be  most-specific  to
	      least-specific  for common use cases.  Projects may override the
	      order by simply calling the command multiple times and using the
	      NO_* options:

		 find_program(<VAR> NAMES name PATHS paths... NO_DEFAULT_PATH)
		 find_program(<VAR> NAMES name)

	      Once  one	 of the calls succeeds the result variable will be set
	      and stored in the cache so that no call will search again.

       foreach
	      Evaluate a group of commands for each value in a list.

		foreach(loop_var arg1 arg2 ...)
		  COMMAND1(ARGS ...)
		  COMMAND2(ARGS ...)
		  ...
		endforeach(loop_var)

	      All commands between foreach and	the  matching  endforeach  are
	      recorded	without	 being invoked.	 Once the endforeach is evalu‐
	      ated, the recorded list of commands is  invoked  once  for  each
	      argument	listed	in  the original foreach command.  Before each
	      iteration of the loop "${loop_var}" will be set  as  a  variable
	      with the current value in the list.

		foreach(loop_var RANGE total)
		foreach(loop_var RANGE start stop [step])

	      Foreach  can  also  iterate  over	 a generated range of numbers.
	      There are three types of this iteration:

	      * When specifying single number, the range will have elements  0
	      to "total".

	      * When specifying two numbers, the range will have elements from
	      the first number to the second number.

	      * The third optional number is the  increment  used  to  iterate
	      from the first number to the second number.

		foreach(loop_var IN [LISTS [list1 [...]]]
				    [ITEMS [item1 [...]]])

	      Iterates	over  a precise list of items.	The LISTS option names
	      list-valued variables to be traversed, including empty  elements
	      (an  empty string is a zero-length list).	 The ITEMS option ends
	      argument parsing and includes all arguments following it in  the
	      iteration.

       function
	      Start recording a function for later invocation as a command.

		function(<name> [arg1 [arg2 [arg3 ...]]])
		  COMMAND1(ARGS ...)
		  COMMAND2(ARGS ...)
		  ...
		endfunction(<name>)

	      Define  a	 function named <name> that takes arguments named arg1
	      arg2 arg3 (...).	Commands listed after function, but before the
	      matching	endfunction,  are  not	invoked	 until the function is
	      invoked.	When it is invoked, the commands recorded in the func‐
	      tion are first modified by replacing formal parameters (${arg1})
	      with the arguments passed, and then invoked as normal  commands.
	      In  addition to referencing the formal parameters you can refer‐
	      ence the variable ARGC which will be set to the number of	 argu‐
	      ments  passed into the function as well as ARGV0 ARGV1 ARGV2 ...
	      which will have the actual values of the	arguments  passed  in.
	      This  facilitates	 creating  functions  with optional arguments.
	      Additionally ARGV holds the list of all arguments given  to  the
	      function	and  ARGN  holds  the  list of arguments past the last
	      expected argument.

	      A function opens a new  scope:  see  set(var  PARENT_SCOPE)  for
	      details.

	      See the cmake_policy() command documentation for the behavior of
	      policies inside functions.

       get_cmake_property
	      Get a property of the CMake instance.

		get_cmake_property(VAR property)

	      Get a property from the CMake instance.  The value of the	 prop‐
	      erty  is	stored	in  the	 variable VAR.	If the property is not
	      found, VAR will be set to "NOTFOUND".  Some supported properties
	      include:	VARIABLES, CACHE_VARIABLES, COMMANDS, MACROS, and COM‐
	      PONENTS.

	      See also the more general get_property() command.

       get_directory_property
	      Get a property of DIRECTORY scope.

		get_directory_property(<variable> [DIRECTORY <dir>] <prop-name>)

	      Store a property of directory scope in the named	variable.   If
	      the  property  is not defined the empty-string is returned.  The
	      DIRECTORY argument specifies another  directory  from  which  to
	      retrieve	the property value.  The specified directory must have
	      already been traversed by CMake.

		get_directory_property(<variable> [DIRECTORY <dir>]
				       DEFINITION <var-name>)

	      Get a variable definition from a directory.  This form is useful
	      to get a variable definition from another directory.

	      See also the more general get_property() command.

       get_filename_component
	      Get a specific component of a full filename.

		get_filename_component(<VAR> <FileName> <COMP> [CACHE])

	      Set <VAR> to a component of <FileName>, where <COMP> is one of:

	       DIRECTORY = Directory without file name
	       NAME	 = File name without directory
	       EXT	 = File name longest extension (.b.c from d/a.b.c)
	       NAME_WE	 = File name without directory or longest extension
	       ABSOLUTE	 = Full path to file
	       REALPATH	 = Full path to existing file with symlinks resolved
	       PATH	 = Legacy alias for DIRECTORY (use for CMake <= 2.8.11)

	      Paths  are  returned  with  forward slashes and have no trailing
	      slahes. The longest file extension is always considered. If  the
	      optional	CACHE  argument	 is  specified, the result variable is
	      added to the cache.

		get_filename_component(<VAR> FileName
				       PROGRAM [PROGRAM_ARGS <ARG_VAR>]
				       [CACHE])

	      The program in FileName will be found in the system search  path
	      or  left	as  a full path.  If PROGRAM_ARGS is present with PRO‐
	      GRAM, then any command-line arguments present  in	 the  FileName
	      string  are split from the program name and stored in <ARG_VAR>.
	      This is used to separate a program name from its arguments in  a
	      command line string.

       get_property
	      Get a property.

		get_property(<variable>
			     <GLOBAL		 |
			      DIRECTORY [dir]	 |
			      TARGET	<target> |
			      SOURCE	<source> |
			      TEST	<test>	 |
			      CACHE	<entry>	 |
			      VARIABLE>
			     PROPERTY <name>
			     [SET | DEFINED | BRIEF_DOCS | FULL_DOCS])

	      Get one property from one object in a scope.  The first argument
	      specifies the variable in which to store the result.  The second
	      argument	determines  the	 scope from which to get the property.
	      It must be one of the following:

	      GLOBAL scope is unique and does not accept a name.

	      DIRECTORY scope defaults to the current  directory  but  another
	      directory	 (already  processed by CMake) may be named by full or
	      relative path.

	      TARGET scope must name one existing target.

	      SOURCE scope must name one source file.

	      TEST scope must name one existing test.

	      CACHE scope must name one cache entry.

	      VARIABLE scope is unique and does not accept a name.

	      The required PROPERTY option is immediately followed by the name
	      of  the  property	 to  get.  If the property is not set an empty
	      value is returned.  If the SET option is given the  variable  is
	      set  to a boolean value indicating whether the property has been
	      set.  If the DEFINED option is given the variable is  set	 to  a
	      boolean  value  indicating whether the property has been defined
	      such as with define_property.  If	 BRIEF_DOCS  or	 FULL_DOCS  is
	      given then the variable is set to a string containing documenta‐
	      tion for the requested property.	If documentation is  requested
	      for a property that has not been defined NOTFOUND is returned.

       if     Conditionally execute a group of commands.

		if(expression)
		  # then section.
		  COMMAND1(ARGS ...)
		  COMMAND2(ARGS ...)
		  ...
		elseif(expression2)
		  # elseif section.
		  COMMAND1(ARGS ...)
		  COMMAND2(ARGS ...)
		  ...
		else(expression)
		  # else section.
		  COMMAND1(ARGS ...)
		  COMMAND2(ARGS ...)
		  ...
		endif(expression)

	      Evaluates the given expression.  If the result is true, the com‐
	      mands in the THEN section are invoked.  Otherwise, the  commands
	      in  the  else section are invoked.  The elseif and else sections
	      are optional. You may have multiple elseif  clauses.  Note  that
	      the  expression  in  the else and endif clause is optional. Long
	      expressions can be used and there	 is  a	traditional  order  of
	      precedence.  Parenthetical  expressions are evaluated first fol‐
	      lowed by unary operators such as EXISTS, COMMAND,	 and  DEFINED.
	      Then  any	 EQUAL,	 LESS, GREATER, STRLESS, STRGREATER, STREQUAL,
	      MATCHES will be evaluated. Then NOT operators and	 finally  AND,
	      OR operators will be evaluated. Possible expressions are:

		if(<constant>)

	      True  if the constant is 1, ON, YES, TRUE, Y, or a non-zero num‐
	      ber.  False if the constant is 0, OFF,  NO,  FALSE,  N,  IGNORE,
	      NOTFOUND,	 '', or ends in the suffix '-NOTFOUND'.	 Named boolean
	      constants are case-insensitive.  If the argument is not  one  of
	      these constants, it is treated as a variable:

		if(<variable>)

	      True  if	the variable is defined to a value that is not a false
	      constant.	 False otherwise.  (Note macro arguments are not vari‐
	      ables.)

		if(NOT <expression>)

	      True if the expression is not true.

		if(<expr1> AND <expr2>)

	      True if both expressions would be considered true individually.

		if(<expr1> OR <expr2>)

	      True if either expression would be considered true individually.

		if(COMMAND command-name)

	      True  if the given name is a command, macro or function that can
	      be invoked.

		if(POLICY policy-id)

	      True if the given name  is  an  existing	policy	(of  the  form
	      CMP<NNNN>).

		if(TARGET target-name)

	      True if the given name is an existing target, built or imported.

		if(EXISTS file-name)
		if(EXISTS directory-name)

	      True  if	the  named  file  or  directory	 exists.   Behavior is
	      well-defined only for full paths.

		if(file1 IS_NEWER_THAN file2)

	      True if file1 is newer than file2 or if one  of  the  two	 files
	      doesn't  exist. Behavior is well-defined only for full paths. If
	      the file time stamps are exactly the same, an IS_NEWER_THAN com‐
	      parison  returns	true,  so  that any dependent build operations
	      will occur in the event of a tie.	 This  includes	 the  case  of
	      passing the same file name for both file1 and file2.

		if(IS_DIRECTORY directory-name)

	      True if the given name is a directory.  Behavior is well-defined
	      only for full paths.

		if(IS_SYMLINK file-name)

	      True if  the  given  name	 is  a	symbolic  link.	  Behavior  is
	      well-defined only for full paths.

		if(IS_ABSOLUTE path)

	      True if the given path is an absolute path.

		if(<variable|string> MATCHES regex)

	      True  if	the given string or variable's value matches the given
	      regular expression.

		if(<variable|string> LESS <variable|string>)
		if(<variable|string> GREATER <variable|string>)
		if(<variable|string> EQUAL <variable|string>)

	      True if the given string or variable's value is a	 valid	number
	      and the inequality or equality is true.

		if(<variable|string> STRLESS <variable|string>)
		if(<variable|string> STRGREATER <variable|string>)
		if(<variable|string> STREQUAL <variable|string>)

	      True  if	the  given string or variable's value is lexicographi‐
	      cally less (or greater, or equal) than the string or variable on
	      the right.

		if(<variable|string> VERSION_LESS <variable|string>)
		if(<variable|string> VERSION_EQUAL <variable|string>)
		if(<variable|string> VERSION_GREATER <variable|string>)

	      Component-wise integer version number comparison (version format
	      is major[.minor[.patch[.tweak]]]).

		if(DEFINED <variable>)

	      True if the given variable is defined. It does not matter if the
	      variable is true or false just if it has been set.

		if((expression) AND (expression OR (expression)))

	      The  expressions	inside the parenthesis are evaluated first and
	      then the remaining expression is evaluated as  in	 the  previous
	      examples.	 Where	there are nested parenthesis the innermost are
	      evaluated as part of evaluating  the  expression	that  contains
	      them.

	      The  if  command was written very early in CMake's history, pre‐
	      dating the ${} variable evaluation syntax, and  for  convenience
	      evaluates variables named by its arguments as shown in the above
	      signatures.  Note	 that  normal  variable	 evaluation  with  ${}
	      applies  before  the  if	command	 even  receives the arguments.
	      Therefore code like

		set(var1 OFF)
		set(var2 "var1")
		if(${var2})

	      appears to the if command as

		if(var1)

	      and is evaluated according to the if(<variable>) case documented
	      above.  The result is OFF which is false.	 However, if we remove
	      the ${} from the example then the command sees

		if(var2)

	      which is true because var2 is defined to "var1" which is	not  a
	      false constant.

	      Automatic	 evaluation  applies  in  the other cases whenever the
	      above-documented signature accepts <variable|string>:

	      1) The left hand argument to MATCHES is first checked to see  if
	      it  is  a	 defined variable, if so the variable's value is used,
	      otherwise the original value is used.

	      2) If the left hand argument to MATCHES is  missing  it  returns
	      false without error

	      3)  Both left and right hand arguments to LESS GREATER EQUAL are
	      independently tested to see if they are defined variables, if so
	      their  defined  values  are used otherwise the original value is
	      used.

	      4) Both left and right hand arguments to STRLESS	STREQUAL  STR‐
	      GREATER  are  independently  tested  to  see if they are defined
	      variables, if so their defined values  are  used	otherwise  the
	      original value is used.

	      5)  Both	left  and  right  hand argumemnts to VERSION_LESS VER‐
	      SION_EQUAL VERSION_GREATER are independently tested  to  see  if
	      they  are defined variables, if so their defined values are used
	      otherwise the original value is used.

	      6) The right hand argument to NOT is tested to see if  it	 is  a
	      boolean  constant,  if  so  the  value  is used, otherwise it is
	      assumed to be a variable and it is dereferenced.

	      7) The left and right hand arguments to AND OR are independently
	      tested to see if they are boolean constants, if so they are used
	      as such, otherwise they are assumed  to  be  variables  and  are
	      dereferenced.

       include
	      Load and run CMake code from a file or module.

		include(<file|module> [OPTIONAL] [RESULT_VARIABLE <VAR>]
				      [NO_POLICY_SCOPE])

	      Load and run CMake code from the file given.  Variable reads and
	      writes access the scope of the  caller  (dynamic	scoping).   If
	      OPTIONAL	is  present,  then no error is raised if the file does
	      not exist.  If RESULT_VARIABLE is given the variable will be set
	      to  the  full filename which has been included or NOTFOUND if it
	      failed.

	      If a module is specified instead of a file, the file  with  name
	      <modulename>.cmake  is searched first in CMAKE_MODULE_PATH, then
	      in the CMake module directory. There is one exception  to	 this:
	      if the file which calls include() is located itself in the CMake
	      module directory, then  first  the  CMake	 module	 directory  is
	      searched	and  CMAKE_MODULE_PATH	afterwards.  See  also	policy
	      CMP0017.

	      See the cmake_policy() command documentation for	discussion  of
	      the NO_POLICY_SCOPE option.

       list   List operations.

		list(LENGTH <list> <output variable>)
		list(GET <list> <element index> [<element index> ...]
		     <output variable>)
		list(APPEND <list> <element> [<element> ...])
		list(FIND <list> <value> <output variable>)
		list(INSERT <list> <element_index> <element> [<element> ...])
		list(REMOVE_ITEM <list> <value> [<value> ...])
		list(REMOVE_AT <list> <index> [<index> ...])
		list(REMOVE_DUPLICATES <list>)
		list(REVERSE <list>)
		list(SORT <list>)

	      LENGTH will return a given list's length.

	      GET  will	 return list of elements specified by indices from the
	      list.

	      APPEND will append elements to the list.

	      FIND will return the index of the element specified in the  list
	      or -1 if it wasn't found.

	      INSERT  will  insert elements to the list to the specified loca‐
	      tion.

	      REMOVE_AT and REMOVE_ITEM will remove items from the  list.  The
	      difference  is  that  REMOVE_ITEM	 will  remove the given items,
	      while REMOVE_AT will remove the items at the given indices.

	      REMOVE_DUPLICATES will remove duplicated items in the list.

	      REVERSE reverses the contents of the list in-place.

	      SORT sorts the list in-place alphabetically.

	      The list subcommands  APPEND,  INSERT,  REMOVE_AT,  REMOVE_ITEM,
	      REMOVE_DUPLICATES,  REVERSE  and	SORT may create new values for
	      the list within the current CMake variable scope. Similar to the
	      SET command, the LIST command creates new variable values in the
	      current scope, even if the list itself is actually defined in  a
	      parent  scope.  To  propagate  the  results  of these operations
	      upwards, use SET with PARENT_SCOPE, SET with CACHE INTERNAL,  or
	      some other means of value propagation.

	      NOTES:  A	 list  in  cmake is a ; separated group of strings. To
	      create a list the set command can be used. For example,  set(var
	      a	 b c d e)  creates a list with a;b;c;d;e, and set(var "a b c d
	      e") creates a string or a list with one item in it.

	      When specifying  index  values,  if  <element  index>  is	 0  or
	      greater,	it  is	indexed from the beginning of the list, with 0
	      representing the first list element. If <element index> is -1 or
	      lesser,  it  is indexed from the end of the list, with -1 repre‐
	      senting the last list element. Be	 careful  when	counting  with
	      negative	indices: they do not start from 0. -0 is equivalent to
	      0, the first list element.

       macro  Start recording a macro for later invocation as a command.

		macro(<name> [arg1 [arg2 [arg3 ...]]])
		  COMMAND1(ARGS ...)
		  COMMAND2(ARGS ...)
		  ...
		endmacro(<name>)

	      Define a macro named <name> that takes arguments named arg1 arg2
	      arg3  (...).  Commands listed after macro, but before the match‐
	      ing endmacro, are not invoked until the macro is invoked.	  When
	      it is invoked, the commands recorded in the macro are first mod‐
	      ified by replacing formal parameters (${arg1})  with  the	 argu‐
	      ments  passed,  and then invoked as normal commands. In addition
	      to referencing the formal parameters you can reference the  val‐
	      ues  ${ARGC} which will be set to the number of arguments passed
	      into the function as well	 as  ${ARGV0}  ${ARGV1}	 ${ARGV2}  ...
	      which  will  have	 the actual values of the arguments passed in.
	      This facilitates creating macros with optional arguments.	 Addi‐
	      tionally	${ARGV}	 holds	the list of all arguments given to the
	      macro and ${ARGN} holds the list	of  arguments  past  the  last
	      expected	argument. Note that the parameters to a macro and val‐
	      ues such as ARGN are not variables in  the  usual	 CMake	sense.
	      They  are string replacements much like the C preprocessor would
	      do with a macro. If you want true CMake variables and/or	better
	      CMake scope control you should look at the function command.

	      See the cmake_policy() command documentation for the behavior of
	      policies inside macros.

       mark_as_advanced
	      Mark cmake cached variables as advanced.

		mark_as_advanced([CLEAR|FORCE] VAR VAR2 VAR...)

	      Mark the named cached variables as advanced.  An advanced	 vari‐
	      able  will  not be displayed in any of the cmake GUIs unless the
	      show advanced option is on.  If  CLEAR  is  the  first  argument
	      advanced	variables are changed back to unadvanced.  If FORCE is
	      the first argument, then the variable is made advanced.  If nei‐
	      ther  FORCE nor CLEAR is specified, new values will be marked as
	      advanced,	  but	 if    the    variable	  already    has    an
	      advanced/non-advanced state, it will not be changed.

	      It does nothing in script mode.

       math   Mathematical expressions.

		math(EXPR <output variable> <math expression>)

	      EXPR evaluates mathematical expression and returns result in the
	      output variable. Example mathematical expression is '5 * ( 10  +
	      13  )'.	Supported operators are + - * / % | & ^ ~ << >> * / %.
	      They have the same meaning  as they do in C code.

       message
	      Display a message to the user.

		message([STATUS|WARNING|AUTHOR_WARNING|FATAL_ERROR|SEND_ERROR]
			"message to display" ...)

	      The optional keyword determines the type of message:

		(none)	       = Important information
		STATUS	       = Incidental information
		WARNING	       = CMake Warning, continue processing
		AUTHOR_WARNING = CMake Warning (dev), continue processing
		SEND_ERROR     = CMake Error, continue processing,
					      but skip generation
		FATAL_ERROR    = CMake Error, stop processing and generation

	      The CMake command-line tool displays STATUS messages  on	stdout
	      and  all	other message types on stderr.	The CMake GUI displays
	      all messages in its log area.  The interactive  dialogs  (ccmake
	      and  CMakeSetup)	show STATUS messages one at a time on a status
	      line and other messages in interactive pop-up boxes.

	      CMake Warning and Error message text  displays  using  a	simple
	      markup language.	Non-indented text is formatted in line-wrapped
	      paragraphs delimited by newlines.	 Indented text	is  considered
	      pre-formatted.

       option Provides an option that the user can optionally select.

		option(<option_variable> "help string describing option"
		       [initial value])

	      Provide  an  option  for the user to select as ON or OFF.	 If no
	      initial value is provided, OFF is used.

	      If you have options that depend on the values of other  options,
	      see the module help for CMakeDependentOption.

       return Return from a file, directory or function.

		return()

	      Returns from a file, directory or function. When this command is
	      encountered in an included file  (via  include()	or  find_pack‐
	      age()),  it  causes  processing  of the current file to stop and
	      control is returned to the including file. If it is  encountered
	      in  a  file which is not included by another file, e.g. a CMake‐
	      Lists.txt, control is returned to the parent directory if	 there
	      is  one.	If return is called in a function, control is returned
	      to the caller of the function. Note that a macro is not a	 func‐
	      tion and does not handle return like a function does.

       separate_arguments
	      Parse space-separated arguments into a semicolon-separated list.

		separate_arguments(<var> <UNIX|WINDOWS>_COMMAND "<args>")

	      Parses a unix- or windows-style command-line string "<args>" and
	      stores a semicolon-separated list of  the	 arguments  in	<var>.
	      The entire command line must be given in one "<args>" argument.

	      The  UNIX_COMMAND	 mode  separates  arguments by unquoted white‐
	      space.  It recognizes both single-quote and double-quote	pairs.
	      A	 backslash escapes the next literal character (\" is "); there
	      are no special escapes (\n is just n).

	      The WINDOWS_COMMAND mode parses a windows command-line using the
	      same  syntax  the	 runtime  library  uses	 to  construct argv at
	      startup.	It separates arguments by whitespace that is not  dou‐
	      ble-quoted.   Backslashes	 are  literal unless they precede dou‐
	      ble-quotes.  See the MSDN article "Parsing C Command-Line	 Argu‐
	      ments" for details.

		separate_arguments(VARIABLE)

	      Convert  the  value  of VARIABLE to a semi-colon separated list.
	      All spaces are replaced with ';'.	 This  helps  with  generating
	      command lines.

       set    Set a CMake, cache or environment variable to a given value.

		set(<variable> <value>
		    [[CACHE <type> <docstring> [FORCE]] | PARENT_SCOPE])

	      Within  CMake  sets <variable> to the value <value>.  <value> is
	      expanded before <variable> is set to it.	Normally, set will set
	      a	 regular  CMake variable. If CACHE is present, then the <vari‐
	      able> is put in the cache instead, unless it is already  in  the
	      cache.  See  section 'Variable types in CMake' below for details
	      of regular and cache variables and their interactions. If	 CACHE
	      is  used, <type> and <docstring> are required. <type> is used by
	      the CMake GUI to choose a widget with  which  the	 user  sets  a
	      value. The value for <type> may be one of

		FILEPATH = File chooser dialog.
		PATH	 = Directory chooser dialog.
		STRING	 = Arbitrary string.
		BOOL	 = Boolean ON/OFF checkbox.
		INTERNAL = No GUI entry (used for persistent variables).

	      If <type> is INTERNAL, the cache variable is marked as internal,
	      and will not be shown to the user in tools like cmake-gui.  This
	      is  intended  for	 values that should be persisted in the cache,
	      but which users should not  normally  change.  INTERNAL  implies
	      FORCE.

	      Normally, set(...CACHE...) creates cache variables, but does not
	      modify them. If FORCE is specified, the value of the cache vari‐
	      able  is set, even if the variable is already in the cache. This
	      should normally be avoided, as it will remove any changes to the
	      cache variable's value by the user.

	      If  PARENT_SCOPE	is  present,  the  variable will be set in the
	      scope above the current scope. Each new  directory  or  function
	      creates  a new scope. This command will set the value of a vari‐
	      able into the parent directory or calling function (whichever is
	      applicable to the case at hand). PARENT_SCOPE cannot be combined
	      with CACHE.

	      If <value> is not specified then the variable is removed instead
	      of set.  See also: the unset() command.

		set(<variable> <value1> ... <valueN>)

	      In  this case <variable> is set to a semicolon separated list of
	      values.

	      <variable> can be an environment variable such as:

		set( ENV{PATH} /home/martink )

	      in which case the environment variable will be set.

	      *** Variable types in CMake ***

	      In CMake there are two types of variables: normal variables  and
	      cache variables. Normal variables are meant for the internal use
	      of the script (just like	variables  in  most  programming  lan‐
	      guages);	they  are not persisted across CMake runs. Cache vari‐
	      ables (unless set with INTERNAL) are mostly intended for config‐
	      uration settings where the first CMake run determines a suitable
	      default value, which the user can then override, by editing  the
	      cache  with  tools  such as ccmake or cmake-gui. Cache variables
	      are stored in the CMake cache file,  and	are  persisted	across
	      CMake runs.

	      Both  types  can	exist  at the same time with the same name but
	      different values. When ${FOO} is evaluated,  CMake  first	 looks
	      for  a normal variable 'FOO' in scope and uses it if set. If and
	      only if no normal variable exists then  it  falls	 back  to  the
	      cache variable 'FOO'.

	      Some examples:

	      The  code 'set(FOO "x")' sets the normal variable 'FOO'. It does
	      not touch the cache, but it will hide any existing  cache	 value
	      'FOO'.

	      The code 'set(FOO "x" CACHE ...)' checks for 'FOO' in the cache,
	      ignoring any normal variable of the same name. If	 'FOO'	is  in
	      the  cache then nothing happens to either the normal variable or
	      the cache variable. If 'FOO' is not in the  cache,  then	it  is
	      added to the cache.

	      Finally,	whenever  a  cache  variable is added or modified by a
	      command, CMake also *removes* the normal variable	 of  the  same
	      name  from  the  current	scope so that an immediately following
	      evaluation of it will expose the newly cached value.

	      Normally projects should avoid using normal and cache  variables
	      of  the  same  name,  as this interaction can be hard to follow.
	      However, in some situations it can be useful. One example	 (used
	      by some projects):

	      A project has a subproject in its source tree. The child project
	      has its own CMakeLists.txt, which is included  from  the	parent
	      CMakeLists.txt  using add_subdirectory(). Now, if the parent and
	      the child project provide the same option (for  example  a  com‐
	      piler  option),  the  parent  gets  the  first  chance  to add a
	      user-editable option to the cache.  Normally,  the  child	 would
	      then use the same value that the parent uses. However, it may be
	      necessary to hard-code the value for the child project's	option
	      while still allowing the user to edit the value used by the par‐
	      ent project. The parent project can achieve this simply by  set‐
	      ting  a  normal  variable	 with the same name as the option in a
	      scope sufficient to hide the option's cache  variable  from  the
	      child completely. The parent has already set the cache variable,
	      so the child's set(...CACHE...) will do nothing, and  evaluating
	      the option variable will use the value from the normal variable,
	      which hides the cache variable.

       set_directory_properties
	      Set a property of the directory.

		set_directory_properties(PROPERTIES prop1 value1 prop2 value2)

	      Set a property for the current directory and subdirectories.  If
	      the property is not found, CMake will report an error. The prop‐
	      erties	include:    INCLUDE_DIRECTORIES,     LINK_DIRECTORIES,
	      INCLUDE_REGULAR_EXPRESSION,   and	  ADDITIONAL_MAKE_CLEAN_FILES.
	      ADDITIONAL_MAKE_CLEAN_FILES is a list  of	 files	that  will  be
	      cleaned as a part of "make clean" stage.

       set_property
	      Set a named property in a given scope.

		set_property(<GLOBAL				|
			      DIRECTORY [dir]			|
			      TARGET	[target1 [target2 ...]] |
			      SOURCE	[src1 [src2 ...]]	|
			      TEST	[test1 [test2 ...]]	|
			      CACHE	[entry1 [entry2 ...]]>
			     [APPEND] [APPEND_STRING]
			     PROPERTY <name> [value1 [value2 ...]])

	      Set  one property on zero or more objects of a scope.  The first
	      argument determines the scope in which the property is set.   It
	      must be one of the following:

	      GLOBAL scope is unique and does not accept a name.

	      DIRECTORY	 scope	defaults  to the current directory but another
	      directory (already processed by CMake) may be named by  full  or
	      relative path.

	      TARGET scope may name zero or more existing targets.

	      SOURCE  scope  may  name	zero  or more source files.  Note that
	      source file properties are visible only to targets added in  the
	      same directory (CMakeLists.txt).

	      TEST scope may name zero or more existing tests.

	      CACHE scope must name zero or more cache existing entries.

	      The required PROPERTY option is immediately followed by the name
	      of the property to set.  Remaining arguments are used to compose
	      the  property  value  in the form of a semicolon-separated list.
	      If the APPEND option is given the list is appended to any exist‐
	      ing  property  value.If  the  APPEND_STRING  option is given the
	      string is append to any existing property value as string,  i.e.
	      it results in a longer string and not a list of strings.

       site_name
	      Set the given variable to the name of the computer.

		site_name(variable)

       string String operations.

		string(REGEX MATCH <regular_expression>
		       <output variable> <input> [<input>...])
		string(REGEX MATCHALL <regular_expression>
		       <output variable> <input> [<input>...])
		string(REGEX REPLACE <regular_expression>
		       <replace_expression> <output variable>
		       <input> [<input>...])
		string(REPLACE <match_string>
		       <replace_string> <output variable>
		       <input> [<input>...])
		string(<MD5|SHA1|SHA224|SHA256|SHA384|SHA512>
		       <output variable> <input>)
		string(COMPARE EQUAL <string1> <string2> <output variable>)
		string(COMPARE NOTEQUAL <string1> <string2> <output variable>)
		string(COMPARE LESS <string1> <string2> <output variable>)
		string(COMPARE GREATER <string1> <string2> <output variable>)
		string(ASCII <number> [<number> ...] <output variable>)
		string(CONFIGURE <string1> <output variable>
		       [@ONLY] [ESCAPE_QUOTES])
		string(TOUPPER <string1> <output variable>)
		string(TOLOWER <string1> <output variable>)
		string(LENGTH <string> <output variable>)
		string(SUBSTRING <string> <begin> <length> <output variable>)
		string(STRIP <string> <output variable>)
		string(RANDOM [LENGTH <length>] [ALPHABET <alphabet>]
		       [RANDOM_SEED <seed>] <output variable>)
		string(FIND <string> <substring> <output variable> [REVERSE])
		string(TIMESTAMP <output variable> [<format string>] [UTC])
		string(MAKE_C_IDENTIFIER <input string> <output variable>)

	      REGEX MATCH will match the regular expression once and store the
	      match in the output variable.

	      REGEX MATCHALL will match the regular expression as  many	 times
	      as  possible  and	 store the matches in the output variable as a
	      list.

	      REGEX REPLACE will match the regular expression as many times as
	      possible and substitute the replacement expression for the match
	      in the output.  The replace expression may refer to paren-delim‐
	      ited  subexpressions  of	the match using \1, \2, ..., \9.  Note
	      that two backslashes (\\1) are required in CMake code to	get  a
	      backslash through argument parsing.

	      REPLACE  will  replace  all  occurrences	of match_string in the
	      input with replace_string and store the result in the output.

	      MD5, SHA1, SHA224, SHA256, SHA384, and  SHA512  will  compute  a
	      cryptographic hash of the input string.

	      COMPARE EQUAL/NOTEQUAL/LESS/GREATER will compare the strings and
	      store true or false in the output variable.

	      ASCII will convert all numbers into corresponding ASCII  charac‐
	      ters.

	      CONFIGURE will transform a string like CONFIGURE_FILE transforms
	      a file.

	      TOUPPER/TOLOWER will convert string to upper/lower characters.

	      LENGTH will return a given string's length.

	      SUBSTRING will return a substring of a given string.  If	length
	      is  -1  the  remainder  of  the string starting at begin will be
	      returned.

	      STRIP will return a substring of a given string with leading and
	      trailing spaces removed.

	      RANDOM will return a random string of given length consisting of
	      characters from the given alphabet. Default length is 5  charac‐
	      ters  and	 default  alphabet  is all numbers and upper and lower
	      case letters.  If an integer RANDOM_SEED	is  given,  its	 value
	      will be used to seed the random number generator.

	      FIND  will  return  the  position	 where the given substring was
	      found in the supplied string. If the REVERSE flag was used,  the
	      command  will  search for the position of the last occurrence of
	      the specified substring.

	      The following characters have special meaning in regular expres‐
	      sions:

		 ^	   Matches at beginning of input
		 $	   Matches at end of input
		 .	   Matches any single character
		 [ ]	   Matches any character(s) inside the brackets
		 [^ ]	   Matches any character(s) not inside the brackets
		  -	   Inside brackets, specifies an inclusive range between
			   characters on either side e.g. [a-f] is [abcdef]
			   To match a literal - using brackets, make it the first
			   or the last character e.g. [+*/-] matches basic
			   mathematical operators.
		 *	   Matches preceding pattern zero or more times
		 +	   Matches preceding pattern one or more times
		 ?	   Matches preceding pattern zero or once only
		 |	   Matches a pattern on either side of the |
		 ()	   Saves a matched subexpression, which can be referenced
			   in the REGEX REPLACE operation. Additionally it is saved
			   by all regular expression-related commands, including
			   e.g. if( MATCHES ), in the variables CMAKE_MATCH_(0..9).

	      *,  +  and  ?  have  higher precedence than concatenation. | has
	      lower precedence than concatenation. This means that the regular
	      expression "^ab+d$" matches "abbd" but not "ababd", and the reg‐
	      ular expression "^(ab|cd)$" matches "ab" but not "abd".

	      TIMESTAMP will write a string representation of the current date
	      and/or time to the output variable.

	      Should  the  command  be unable to obtain a timestamp the output
	      variable will be set to the empty string "".

	      The optional UTC flag requests the current date/time representa‐
	      tion to be in Coordinated Universal Time (UTC) rather than local
	      time.

	      The optional <format string> may contain	the  following	format
	      specifiers:

		 %d	   The day of the current month (01-31).
		 %H	   The hour on a 24-hour clock (00-23).
		 %I	   The hour on a 12-hour clock (01-12).
		 %j	   The day of the current year (001-366).
		 %m	   The month of the current year (01-12).
		 %M	   The minute of the current hour (00-59).
		 %S	   The second of the current minute.
			   60 represents a leap second. (00-60)
		 %U	   The week number of the current year (00-53).
		 %w	   The day of the current week. 0 is Sunday. (0-6)
		 %y	   The last two digits of the current year (00-99)
		 %Y	   The current year.

	      Unknown format specifiers will be ignored and copied to the out‐
	      put as-is.

	      If no explicit <format string> is given it will default to:

		 %Y-%m-%dT%H:%M:%S    for local time.
		 %Y-%m-%dT%H:%M:%SZ   for UTC.

	      MAKE_C_IDENTIFIER will write a string which can be  used	as  an
	      identifier in C.

       unset  Unset a variable, cache variable, or environment variable.

		unset(<variable> [CACHE])

	      Removes  the  specified variable causing it to become undefined.
	      If CACHE is present then the variable is removed from the	 cache
	      instead of the current scope.

	      <variable> can be an environment variable such as:

		unset(ENV{LD_LIBRARY_PATH})

	      in  which	 case  the  variable  will be removed from the current
	      environment.

       variable_watch
	      Watch the CMake variable for change.

		variable_watch(<variable name> [<command to execute>])

	      If the specified variable changes, the message will  be  printed
	      about  the  variable being changed. If the command is specified,
	      the command will be executed. The command will receive the  fol‐
	      lowing  arguments:  COMMAND(<variable> <access> <value> <current
	      list file> <stack>)

       while  Evaluate a group of commands while a condition is true

		while(condition)
		  COMMAND1(ARGS ...)
		  COMMAND2(ARGS ...)
		  ...
		endwhile(condition)

	      All  commands  between  while  and  the  matching	 endwhile  are
	      recorded without being invoked.  Once the endwhile is evaluated,
	      the recorded list of commands is invoked as long as  the	condi‐
	      tion is true. The condition is evaluated using the same logic as
	      the if command.

COMPATIBILITY COMMANDS
	 CMake Compatibility Listfile Commands - Obsolete commands supported by CMake for compatibility.

       This is the documentation for now obsolete listfile commands from  pre‐
       vious  CMake versions, which are still supported for compatibility rea‐
       sons. You should instead use the newer, faster  and  shinier  new  com‐
       mands. ;-)

MODULES
PROPERTIES OF GLOBAL SCOPE
       ALLOW_DUPLICATE_CUSTOM_TARGETS
	      Allow duplicate custom targets to be created.

	      Normally CMake requires that all targets built in a project have
	      globally unique logical names (see  policy  CMP0002).   This  is
	      necessary to generate meaningful project file names in Xcode and
	      VS IDE generators.  It also allows the target names to be refer‐
	      enced unambiguously.

	      Makefile	generators  are capable of supporting duplicate custom
	      target names.  For projects that care only about Makefile gener‐
	      ators and do not wish to support Xcode or VS IDE generators, one
	      may set this property to true to allow duplicate custom targets.
	      The  property allows multiple add_custom_target command calls in
	      different directories to specify the same target name.  However,
	      setting this property will cause non-Makefile generators to pro‐
	      duce an error and refuse to generate the project.

       AUTOMOC_TARGETS_FOLDER
	      Name of FOLDER for *_automoc targets that	 are  added  automati‐
	      cally by CMake for targets for which AUTOMOC is enabled.

	      If  not set, CMake uses the FOLDER property of the parent target
	      as a default value for this property. See also the documentation
	      for the FOLDER target property and the AUTOMOC target property.

       DEBUG_CONFIGURATIONS
	      Specify which configurations are for debugging.

	      The  value  must be a semi-colon separated list of configuration
	      names.  Currently	 this  property	 is  used  only	 by  the  tar‐
	      get_link_libraries  command (see its documentation for details).
	      Additional uses may be defined in the future.

	      This property must be set at the top level of  the  project  and
	      before  the  first target_link_libraries command invocation.  If
	      any entry in the list does not match a valid  configuration  for
	      the project the behavior is undefined.

       DISABLED_FEATURES
	      List of features which are disabled during the CMake run.

	      List  of	features  which	 are disabled during the CMake run. By
	      default it contains the names of all  packages  which  were  not
	      found.  This  is	determined  using  the <NAME>_FOUND variables.
	      Packages which are searched QUIET are not listed. A project  can
	      add  its own features to this list. This property is used by the
	      macros in FeatureSummary.cmake.

       ENABLED_FEATURES
	      List of features which are enabled during the CMake run.

	      List of features which are enabled  during  the  CMake  run.  By
	      default  it contains the names of all packages which were found.
	      This is determined using the  <NAME>_FOUND  variables.  Packages
	      which  are  searched QUIET are not listed. A project can add its
	      own features to this list. This property is used by  the	macros
	      in FeatureSummary.cmake.

       ENABLED_LANGUAGES
	      Read-only	 property  that contains the list of currently enabled
	      languages

	      Set to list of currently enabled languages.

       FIND_LIBRARY_USE_LIB64_PATHS
	      Whether FIND_LIBRARY should automatically search lib64  directo‐
	      ries.

	      FIND_LIBRARY_USE_LIB64_PATHS is a boolean specifying whether the
	      FIND_LIBRARY command should automatically search the lib64 vari‐
	      ant  of  directories called lib in the search path when building
	      64-bit binaries.

       FIND_LIBRARY_USE_OPENBSD_VERSIONING
	      Whether FIND_LIBRARY should find OpenBSD-style shared libraries.

	      This property is a boolean specifying whether  the  FIND_LIBRARY
	      command  should  find  shared  libraries with OpenBSD-style ver‐
	      sioned extension: ".so.<major>.<minor>".	The property is set to
	      true on OpenBSD and false on other platforms.

       GLOBAL_DEPENDS_DEBUG_MODE
	      Enable global target dependency graph debug mode.

	      CMake  automatically analyzes the global inter-target dependency
	      graph at the beginning of native build system generation.	  This
	      property causes it to display details of its analysis to stderr.

       GLOBAL_DEPENDS_NO_CYCLES
	      Disallow global target dependency graph cycles.

	      CMake  automatically analyzes the global inter-target dependency
	      graph at the beginning of native build  system  generation.   It
	      reports  an  error if the dependency graph contains a cycle that
	      does not consist of all STATIC library targets.	This  property
	      tells CMake to disallow all cycles completely, even among static
	      libraries.

       IN_TRY_COMPILE
	      Read-only property that is true during a try-compile  configura‐
	      tion.

	      True  when  building  a  project inside a TRY_COMPILE or TRY_RUN
	      command.

       PACKAGES_FOUND
	      List of packages which were found during the CMake run.

	      List of packages which were found during the CMake run.  Whether
	      a	 package  has  been found is determined using the <NAME>_FOUND
	      variables.

       PACKAGES_NOT_FOUND
	      List of packages which were not found during the CMake run.

	      List of packages which were not  found  during  the  CMake  run.
	      Whether  a  package  has	been  found  is	 determined  using the
	      <NAME>_FOUND variables.

       PREDEFINED_TARGETS_FOLDER
	      Name of FOLDER for  targets  that	 are  added  automatically  by
	      CMake.

	      If  not  set,  CMake  uses "CMakePredefinedTargets" as a default
	      value for this property. Targets such as	INSTALL,  PACKAGE  and
	      RUN_TESTS will be organized into this FOLDER. See also the docu‐
	      mentation for the FOLDER target property.

       REPORT_UNDEFINED_PROPERTIES
	      If set, report any undefined properties to this file.

	      If this property is set to a filename then when  CMake  runs  it
	      will  report  any properties or variables that were accessed but
	      not defined into the filename specified in this property.

       RULE_LAUNCH_COMPILE
	      Specify a launcher for compile rules.

	      Makefile generators prefix  compiler  commands  with  the	 given
	      launcher	command	 line.	This is intended to allow launchers to
	      intercept build problems with  high  granularity.	  Non-Makefile
	      generators currently ignore this property.

       RULE_LAUNCH_CUSTOM
	      Specify a launcher for custom rules.

	      Makefile	generators  prefix  custom  commands  with  the	 given
	      launcher command line.  This is intended to allow	 launchers  to
	      intercept	 build	problems  with high granularity.  Non-Makefile
	      generators currently ignore this property.

       RULE_LAUNCH_LINK
	      Specify a launcher for link rules.

	      Makefile generators prefix link and archive  commands  with  the
	      given  launcher command line.  This is intended to allow launch‐
	      ers  to  intercept  build	 problems   with   high	  granularity.
	      Non-Makefile generators currently ignore this property.

       RULE_MESSAGES
	      Specify whether to report a message for each make rule.

	      This property specifies whether Makefile generators should add a
	      progress message describing what each build rule does.   If  the
	      property	is not set the default is ON.  Set the property to OFF
	      to disable granular messages and report only as each target com‐
	      pletes.	This is intended to allow scripted builds to avoid the
	      build time cost of detailed reports.  If	a  CMAKE_RULE_MESSAGES
	      cache entry exists its value initializes the value of this prop‐
	      erty.  Non-Makefile generators currently ignore this property.

       TARGET_ARCHIVES_MAY_BE_SHARED_LIBS
	      Set if shared libraries may be named like archives.

	      On AIX shared libraries may be named "lib<name>.a".  This	 prop‐
	      erty is set to true on such platforms.

       TARGET_SUPPORTS_SHARED_LIBS
	      Does the target platform support shared libraries.

	      TARGET_SUPPORTS_SHARED_LIBS  is a boolean specifying whether the
	      target platform supports shared libraries. Basically all current
	      general  general	purpose	 OS  do	 so, the exception are usually
	      embedded systems with no or special OSs.

       USE_FOLDERS
	      Use the FOLDER target property to organize targets into folders.

	      If not set, CMake treats this property as OFF by default.	 CMake
	      generators  that	are  capable of organizing into a hierarchy of
	      folders use the values of the FOLDER  target  property  to  name
	      those  folders. See also the documentation for the FOLDER target
	      property.

       __CMAKE_DELETE_CACHE_CHANGE_VARS_
	      Internal property

	      Used to detect compiler changes, Do not set.

PROPERTIES ON CACHE ENTRIES
       ADVANCED
	      True if entry should be hidden by default in GUIs.

	      This is a boolean value indicating whether the entry is  consid‐
	      ered   interesting   only	  for	advanced  configuration.   The
	      mark_as_advanced() command modifies this property.

       HELPSTRING
	      Help associated with entry in GUIs.

	      This string summarizes the purpose of an entry to help users set
	      it through a CMake GUI.

       MODIFIED
	      Internal management property.  Do not set or get.

	      This  is	an  internal  cache entry property managed by CMake to
	      track interactive user modification of entries.  Ignore it.

       STRINGS
	      Enumerate possible STRING entry values for GUI selection.

	      For cache entries with type STRING, this	enumerates  a  set  of
	      values.	CMake  GUIs may use this to provide a selection widget
	      instead of a generic string entry field.	 This  is  for	conve‐
	      nience  only.  CMake does not enforce that the value matches one
	      of those listed.

       TYPE   Widget type for entry in GUIs.

	      Cache entry values are always strings, but  CMake	 GUIs  present
	      widgets to help users set values.	 The GUIs use this property as
	      a hint to determine the widget type.  Valid TYPE values are:

		BOOL	      = Boolean ON/OFF value.
		PATH	      = Path to a directory.
		FILEPATH      = Path to a file.
		STRING	      = Generic string value.
		INTERNAL      = Do not present in GUI at all.
		STATIC	      = Value managed by CMake, do not change.
		UNINITIALIZED = Type not yet specified.

	      Generally the TYPE of a cache entry should be set by the command
	      which creates it (set, option, find_library, etc.).

       VALUE  Value of a cache entry.

	      This  property  maps to the actual value of a cache entry.  Set‐
	      ting this property always sets the value	without	 checking,  so
	      use with care.

PROPERTIES ON DIRECTORIES
       ADDITIONAL_MAKE_CLEAN_FILES
	      Additional files to clean during the make clean stage.

	      A	 list  of  files  that	will be cleaned as a part of the "make
	      clean" stage.

       CACHE_VARIABLES
	      List of cache variables available in the current directory.

	      This read-only property specifies the list of CMake cache	 vari‐
	      ables currently defined.	It is intended for debugging purposes.

       CLEAN_NO_CUSTOM
	      Should the output of custom commands be left.

	      If  this	is  true  then the outputs of custom commands for this
	      directory will not be removed during the "make clean" stage.

       COMPILE_DEFINITIONS
	      Preprocessor definitions for compiling a directory's sources.

	      The COMPILE_DEFINITIONS property may be set to a semicolon-sepa‐
	      rated  list  of preprocessor definitions using the syntax VAR or
	      VAR=value.  Function-style definitions are not supported.	 CMake
	      will  automatically  escape  the	value correctly for the native
	      build system  (note  that	 CMake	language  syntax  may  require
	      escapes  to specify some values).	 This property may be set on a
	      per-configuration basis using the name COMPILE_DEFINITIONS_<CON‐
	      FIG>  where <CONFIG> is an upper-case name (ex. "COMPILE_DEFINI‐
	      TIONS_DEBUG").  This property will be initialized in each direc‐
	      tory by its value in the directory's parent.

	      CMake will automatically drop some definitions that are not sup‐
	      ported by the native build tool.	The VS6 IDE does  not  support
	      definition values with spaces (but NMake does).

	      Disclaimer: Most native build tools have poor support for escap‐
	      ing certain values.  CMake has work-arounds for many  cases  but
	      some  values  may	 just not be possible to pass correctly.  If a
	      value does not seem to be escaped correctly, do not  attempt  to
	      work-around the problem by adding escape sequences to the value.
	      Your work-around may break in a future version of CMake that has
	      improved escape support.	Instead consider defining the macro in
	      a (configured) header file.  Then report the limitation.	 Known
	      limitations include:

		#	   - broken almost everywhere
		;	   - broken in VS IDE 7.0 and Borland Makefiles
		,	   - broken in VS IDE
		%	   - broken in some cases in NMake
		& |	   - broken in some cases on MinGW
		^ < > \"   - broken in most Make tools on Windows

	      CMake does not reject these values outright because they do work
	      in some cases.  Use with caution.

       COMPILE_DEFINITIONS_<CONFIG>
	      Per-configuration preprocessor definitions in a directory.

	      This is the configuration-specific  version  of  COMPILE_DEFINI‐
	      TIONS.   This  property will be initialized in each directory by
	      its value in the directory's parent.

       COMPILE_OPTIONS
	      List of options to pass to the compiler.

	      This property specifies the list of directories given so far for
	      this property.  This property exists on directories and targets.

	      The target property values are used by the generators to set the
	      options for the compiler.

	      Contents of COMPILE_OPTIONS may use "generator expressions" with
	      the syntax "$<...>".  Generator expressions are evaluated during
	      build system generation to produce information specific to  each
	      build configuration.  Valid expressions are:

		$<0:...>		  = empty string (ignores "...")
		$<1:...>		  = content of "..."
		$<CONFIG:cfg>		  = '1' if config is "cfg", else '0'
		$<CONFIGURATION>	  = configuration name
		$<BOOL:...>		  = '1' if the '...' is true, else '0'
		$<STREQUAL:a,b>		  = '1' if a is STREQUAL b, else '0'
		$<ANGLE-R>		  = A literal '>'. Used to compare strings which contain a '>' for example.
		$<COMMA>		  = A literal ','. Used to compare strings which contain a ',' for example.
		$<SEMICOLON>		  = A literal ';'. Used to prevent list expansion on an argument with ';'.
		$<JOIN:list,...>	  = joins the list with the content of "..."
		$<TARGET_NAME:...>	  = Marks ... as being the name of a target.  This is required if exporting targets to multiple dependent export sets.	The '...' must be a literal name of a target- it may not contain generator expressions.
		$<INSTALL_INTERFACE:...>  = content of "..." when the property is exported using install(EXPORT), and empty otherwise.
		$<BUILD_INTERFACE:...>	  = content of "..." when the property is exported using export(), or when the target is used by another target in the same buildsystem. Expands to the empty string otherwise.
		$<C_COMPILER_ID>	  = The CMake-id of the C compiler used.
		$<C_COMPILER_ID:comp>	  = '1' if the CMake-id of the C compiler matches comp, otherwise '0'.
		$<CXX_COMPILER_ID>	  = The CMake-id of the CXX compiler used.
		$<CXX_COMPILER_ID:comp>	  = '1' if the CMake-id of the CXX compiler matches comp, otherwise '0'.
		$<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than v2, else '0'.
		$<VERSION_LESS:v1,v2>	  = '1' if v1 is a version less than v2, else '0'.
		$<VERSION_EQUAL:v1,v2>	  = '1' if v1 is the same version as v2, else '0'.
		$<C_COMPILER_VERSION>	  = The version of the C compiler used.
		$<C_COMPILER_VERSION:ver> = '1' if the version of the C compiler matches ver, otherwise '0'.
		$<CXX_COMPILER_VERSION>	  = The version of the CXX compiler used.
		$<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX compiler matches ver, otherwise '0'.
		$<TARGET_FILE:tgt>	  = main file (.exe, .so.1.2, .a)
		$<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)
		$<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)

	      where  "tgt"  is	the name of a target.  Target file expressions
	      produce a full path, but _DIR and _NAME versions can produce the
	      directory and file name components:

		$<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
		$<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
		$<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>

		$<TARGET_PROPERTY:tgt,prop>   = The value of the property prop on the target tgt.

	      Note  that  tgt  is not added as a dependency of the target this
	      expression is evaluated on.

		$<TARGET_POLICY:pol>	      = '1' if the policy was NEW when the 'head' target was created, else '0'.	 If the policy was not set, the warning message for the policy will be emitted.	 This generator expression only works for a subset of policies.
		$<INSTALL_PREFIX>	  = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise.

	      Boolean expressions:

		$<AND:?[,?]...>		  = '1' if all '?' are '1', else '0'
		$<OR:?[,?]...>		  = '0' if all '?' are '0', else '1'
		$<NOT:?>		  = '0' if '?' is '1', else '1'

	      where '?' is always either '0' or '1'.

	      Expressions with an implicit 'this' target:

		$<TARGET_PROPERTY:prop>	  = The value of the property prop on the target on which the generator expression is evaluated.

       DEFINITIONS
	      For  CMake  2.4  compatibility  only.   Use  COMPILE_DEFINITIONS
	      instead.

	      This read-only property specifies the list of flags given so far
	      to the add_definitions command.  It is  intended	for  debugging
	      purposes.	 Use the COMPILE_DEFINITIONS instead.

       EXCLUDE_FROM_ALL
	      Exclude the directory from the all target of its parent.

	      A	 property  on  a  directory  that indicates if its targets are
	      excluded from the default build target. If it is not, then  with
	      a	 Makefile for example typing make will cause the targets to be
	      built. The same concept applies to the default  build  of	 other
	      generators.

       IMPLICIT_DEPENDS_INCLUDE_TRANSFORM
	      Specify  #include	 line  transforms for dependencies in a direc‐
	      tory.

	      This property specifies rules to transform  macro-like  #include
	      lines  during  implicit  dependency scanning of C and C++ source
	      files.  The list of rules must be semicolon-separated with  each
	      entry  of the form "A_MACRO(%)=value-with-%" (the % must be lit‐
	      eral).  During dependency scanning occurrences  of  A_MACRO(...)
	      on  #include  lines will be replaced by the value given with the
	      macro argument substituted for '%'.  For example, the entry

		MYDIR(%)=<mydir/%>

	      will convert lines of the form

		#include MYDIR(myheader.h)

	      to

		#include <mydir/myheader.h>

	      allowing the dependency to be followed.

	      This property applies to sources in all targets within a	direc‐
	      tory.   The  property  value is initialized in each directory by
	      its value in the directory's parent.

       INCLUDE_DIRECTORIES
	      List of preprocessor include file search directories.

	      This property specifies the list of directories given so far  to
	      the include_directories command.	This property exists on direc‐
	      tories and targets.  In addition to accepting  values  from  the
	      include_directories  command,  values may be set directly on any
	      directory or any target using the set_property command.  A  tar‐
	      get  gets	 its initial value for this property from the value of
	      the directory property.  A directory gets its initial value from
	      its  parent  directory if it has one.  Both directory and target
	      property values are adjusted by calls to the include_directories
	      command.

	      The target property values are used by the generators to set the
	      include paths for the compiler.  See also	 the  include_directo‐
	      ries command.

       INCLUDE_REGULAR_EXPRESSION
	      Include file scanning regular expression.

	      This  read-only  property	 specifies the regular expression used
	      during dependency scanning to match include files that should be
	      followed.	 See the include_regular_expression command.

       INTERPROCEDURAL_OPTIMIZATION
	      Enable interprocedural optimization for targets in a directory.

	      If  set  to  true, enables interprocedural optimizations if they
	      are known to be supported by the compiler.

       INTERPROCEDURAL_OPTIMIZATION_<CONFIG>
	      Per-configuration interprocedural optimization for a directory.

	      This is a per-configuration version of INTERPROCEDURAL_OPTIMIZA‐
	      TION.   If set, this property overrides the generic property for
	      the named configuration.

       LINK_DIRECTORIES
	      List of linker search directories.

	      This read-only property specifies the list of directories	 given
	      so  far  to  the	link_directories  command.  It is intended for
	      debugging purposes.

       LISTFILE_STACK
	      The current stack of listfiles being processed.

	      This property is mainly useful when trying to  debug  errors  in
	      your  CMake  scripts.  It	 returns a list of what list files are
	      currently being processed, in order. So if one listfile does  an
	      INCLUDE  command	then  that is effectively pushing the included
	      listfile onto the stack.

       MACROS List of macro commands available in the current directory.

	      This read-only property specifies the list of CMake macros  cur‐
	      rently defined.  It is intended for debugging purposes.  See the
	      macro command.

       PARENT_DIRECTORY
	      Source directory that added current subdirectory.

	      This read-only property  specifies  the  source  directory  that
	      added  the  current  source  directory  as a subdirectory of the
	      build.   In  the	top-level   directory	the   value   is   the
	      empty-string.

       RULE_LAUNCH_COMPILE
	      Specify a launcher for compile rules.

	      See  the	global	property  of  the same name for details.  This
	      overrides the global property for a directory.

       RULE_LAUNCH_CUSTOM
	      Specify a launcher for custom rules.

	      See the global property of the  same  name  for  details.	  This
	      overrides the global property for a directory.

       RULE_LAUNCH_LINK
	      Specify a launcher for link rules.

	      See  the	global	property  of  the same name for details.  This
	      overrides the global property for a directory.

       TEST_INCLUDE_FILE
	      A cmake file that will be included when ctest is run.

	      If you specify TEST_INCLUDE_FILE, that file will be included and
	      processed when ctest is run on the directory.

       VARIABLES
	      List of variables defined in the current directory.

	      This  read-only  property	 specifies the list of CMake variables
	      currently defined.  It is intended for debugging purposes.

       VS_GLOBAL_SECTION_POST_<section>
	      Specify a postSolution global section in Visual Studio.

	      Setting a property like this generates an entry of the following
	      form in the solution file:

		GlobalSection(<section>) = postSolution
		  <contents based on property value>
		EndGlobalSection

	      The  property  must  be  set  to	a  semicolon-separated list of
	      key=value pairs. Each such pair  will  be	 transformed  into  an
	      entry  in the solution global section. Whitespace around key and
	      value is ignored. List elements which do not  contain  an	 equal
	      sign are skipped.

	      This  property  only  works for Visual Studio 7 and above; it is
	      ignored on other generators. The property only applies when  set
	      on  a  directory	whose CMakeLists.txt contains a project() com‐
	      mand.

	      Note that CMake generates postSolution  sections	Extensibility‐
	      Globals  and ExtensibilityAddIns by default. If you set the cor‐
	      responding property, it will override the default	 section.  For
	      example,	 setting   VS_GLOBAL_SECTION_POST_ExtensibilityGlobals
	      will override the default contents of  the  ExtensibilityGlobals
	      section, while keeping ExtensibilityAddIns on its default.

       VS_GLOBAL_SECTION_PRE_<section>
	      Specify a preSolution global section in Visual Studio.

	      Setting a property like this generates an entry of the following
	      form in the solution file:

		GlobalSection(<section>) = preSolution
		  <contents based on property value>
		EndGlobalSection

	      The property must	 be  set  to  a	 semicolon-separated  list  of
	      key=value	 pairs.	 Each  such  pair  will be transformed into an
	      entry in the solution global section. Whitespace around key  and
	      value  is	 ignored.  List elements which do not contain an equal
	      sign are skipped.

	      This property only works for Visual Studio 7 and	above;	it  is
	      ignored  on other generators. The property only applies when set
	      on a directory whose CMakeLists.txt contains  a  project()  com‐
	      mand.

PROPERTIES ON SOURCE FILES
       ABSTRACT
	      Is this source file an abstract class.

	      A	 property  on  a source file that indicates if the source file
	      represents a class that is abstract. This only makes  sense  for
	      languages that have a notion of an abstract class and it is only
	      used by some tools that wrap classes into other languages.

       COMPILE_DEFINITIONS
	      Preprocessor definitions for compiling a source file.

	      The COMPILE_DEFINITIONS property may be set to a semicolon-sepa‐
	      rated  list  of preprocessor definitions using the syntax VAR or
	      VAR=value.  Function-style definitions are not supported.	 CMake
	      will  automatically  escape  the	value correctly for the native
	      build system  (note  that	 CMake	language  syntax  may  require
	      escapes  to specify some values).	 This property may be set on a
	      per-configuration basis using the name COMPILE_DEFINITIONS_<CON‐
	      FIG>  where <CONFIG> is an upper-case name (ex. "COMPILE_DEFINI‐
	      TIONS_DEBUG").

	      CMake will automatically drop some definitions that are not sup‐
	      ported  by  the native build tool.  The VS6 IDE does not support
	      definition values with spaces (but NMake does).  Xcode does  not
	      support per-configuration definitions on source files.

	      Disclaimer: Most native build tools have poor support for escap‐
	      ing certain values.  CMake has work-arounds for many  cases  but
	      some  values  may	 just not be possible to pass correctly.  If a
	      value does not seem to be escaped correctly, do not  attempt  to
	      work-around the problem by adding escape sequences to the value.
	      Your work-around may break in a future version of CMake that has
	      improved escape support.	Instead consider defining the macro in
	      a (configured) header file.  Then report the limitation.	 Known
	      limitations include:

		#	   - broken almost everywhere
		;	   - broken in VS IDE 7.0 and Borland Makefiles
		,	   - broken in VS IDE
		%	   - broken in some cases in NMake
		& |	   - broken in some cases on MinGW
		^ < > \"   - broken in most Make tools on Windows

	      CMake does not reject these values outright because they do work
	      in some cases.  Use with caution.

       COMPILE_DEFINITIONS_<CONFIG>
	      Per-configuration preprocessor definitions on a source file.

	      This is the configuration-specific  version  of  COMPILE_DEFINI‐
	      TIONS.   Note  that  Xcode  does	not  support per-configuration
	      source file flags so this property will be ignored by the	 Xcode
	      generator.

       COMPILE_FLAGS
	      Additional flags to be added when compiling this source file.

	      These flags will be added to the list of compile flags when this
	      source file builds.  Use COMPILE_DEFINITIONS to pass  additional
	      preprocessor definitions.

       EXTERNAL_OBJECT
	      If set to true then this is an object file.

	      If  this	property is set to true then the source file is really
	      an object file and should not be compiled.   It  will  still  be
	      linked into the target though.

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

	      This  property  tells  CMake whether a given Fortran source file
	      uses fixed-format or free-format.	 CMake will  pass  the	corre‐
	      sponding	format	flag to the compiler.  Consider using the tar‐
	      get-wide Fortran_FORMAT property if all source files in a target
	      share the same format.

       GENERATED
	      Is this source file generated as part of the build process.

	      If  a  source  file is generated by the build process CMake will
	      handle it differently in terms of dependency checking etc.  Oth‐
	      erwise having a non-existent source file could create problems.

       HEADER_FILE_ONLY
	      Is this source file only a header file.

	      A property on a source file that indicates if the source file is
	      a header file with no associated	implementation.	 This  is  set
	      automatically  based  on the file extension and is used by CMake
	      to determine if certain dependency information  should  be  com‐
	      puted.

       KEEP_EXTENSION
	      Make the output file have the same extension as the source file.

	      If  this	property  is set then the file extension of the output
	      file will be the same as that of the source file.	 Normally  the
	      output  file  extension is computed based on the language of the
	      source file, for example .cxx will go to a .o extension.

       LABELS Specify a list of text labels associated with a source file.

	      This property has meaning only when the source file is listed in
	      a	 target whose LABELS property is also set.  No other semantics
	      are currently specified.

       LANGUAGE
	      What programming language is the file.

	      A property that can be set to indicate what programming language
	      the  source file is. If it is not set the language is determined
	      based on the file extension. Typical values are CXX C etc.  Set‐
	      ting  this property for a file means this file will be compiled.
	      Do not set this for headers or files that	 should	 not  be  com‐
	      piled.

       LOCATION
	      The full path to a source file.

	      A	 read  only  property  on a SOURCE FILE that contains the full
	      path to the source file.

       MACOSX_PACKAGE_LOCATION
	      Place a source file inside a  Mac	 OS  X	bundle,	 CFBundle,  or
	      framework.

	      Executable targets with the MACOSX_BUNDLE property set are built
	      as Mac OS X application  bundles	on  Apple  platforms.	Shared
	      library targets with the FRAMEWORK property set are built as Mac
	      OS X frameworks on Apple platforms.  Module library targets with
	      the  BUNDLE  property set are built as Mac OS X CFBundle bundles
	      on Apple platforms.  Source files listed in the target with this
	      property	set will be copied to a directory inside the bundle or
	      framework content folder specified by the property  value.   For
	      bundles the content folder is "<name>.app/Contents".  For frame‐
	      works the	 content  folder  is  "<name>.framework/Versions/<ver‐
	      sion>".  For cfbundles the content folder is "<name>.bundle/Con‐
	      tents"  (unless  the  extension  is  changed).   See  the	  PUB‐
	      LIC_HEADER,  PRIVATE_HEADER,  and RESOURCE target properties for
	      specifying files meant for Headers, PrivateHeaders, or Resources
	      directories.

       OBJECT_DEPENDS
	      Additional files on which a compiled object file depends.

	      Specifies	 a  semicolon-separated list of full-paths to files on
	      which any object files compiled from this	 source	 file  depend.
	      An  object  file will be recompiled if any of the named files is
	      newer than it.

	      This property need not be used to specify the  dependency	 of  a
	      source  file  on	a  generated  header  file  that  it includes.
	      Although the property was originally introduced  for  this  pur‐
	      pose,  it	 is no longer necessary.  If the generated header file
	      is created by a custom command in the same target as the	source
	      file,  the  automatic dependency scanning process will recognize
	      the dependency.  If the generated	 header	 file  is  created  by
	      another  target,	an  inter-target  dependency should be created
	      with the add_dependencies command (if one does not already exist
	      due to linking relationships).

       OBJECT_OUTPUTS
	      Additional outputs for a Makefile rule.

	      Additional  outputs  created by compilation of this source file.
	      If any of these outputs is missing the  object  will  be	recom‐
	      piled. This is supported only on Makefile generators and will be
	      ignored on other generators.

       SYMBOLIC
	      Is this just a name for a rule.

	      If SYMBOLIC (boolean) is set to true the build  system  will  be
	      informed	that  the  source file is not actually created on disk
	      but instead used as a symbolic name for a build rule.

       WRAP_EXCLUDE
	      Exclude this source file from any code wrapping techniques.

	      Some packages can wrap source files into alternate languages  to
	      provide  additional  functionality. For example, C++ code can be
	      wrapped into Java or Python etc using SWIG etc. If  WRAP_EXCLUDE
	      is  set  to  true	 (1  etc) that indicates that this source file
	      should not be wrapped.

PROPERTIES ON TARGETS
       <CONFIG>_OUTPUT_NAME
	      Old per-configuration target file base name.

	      This is a configuration-specific version	of  OUTPUT_NAME.   Use
	      OUTPUT_NAME_<CONFIG> instead.

       <CONFIG>_POSTFIX
	      Postfix  to  append  to  the  target file name for configuration
	      <CONFIG>.

	      When building with configuration	<CONFIG>  the  value  of  this
	      property is appended to the target file name built on disk.  For
	      non-executable targets, this  property  is  initialized  by  the
	      value of the variable CMAKE_<CONFIG>_POSTFIX if it is set when a
	      target is created.  This property is  ignored  on	 the  Mac  for
	      Frameworks and App Bundles.

       <LANG>_VISIBILITY_PRESET
	      Value for symbol visibility compile flags

	      The   <LANG>_VISIBILITY_PRESET  property	determines  the	 value
	      passed in a visibility related compile option, such  as  -fvisi‐
	      bility=  for  <LANG>.   This  property  only  has	 an affect for
	      libraries and executables with exports.  This property  is  ini‐
	      tialized	by  the	 value	of  the variable CMAKE_<LANG>_VISIBIL‐
	      ITY_PRESET if it is set when a target is created.

       ALIASED_TARGET
	      Name of target aliased by this target.

	      If this is an ALIAS target, this property contains the  name  of
	      the target aliased.

       ARCHIVE_OUTPUT_DIRECTORY
	      Output directory in which to build ARCHIVE target files.

	      This  property specifies the directory into which archive target
	      files  should  be	 built.	 Multi-configuration  generators  (VS,
	      Xcode)  append a per-configuration subdirectory to the specified
	      directory.  There are three kinds of target files	 that  may  be
	      built:  archive,	library,  and runtime.	Executables are always
	      treated as runtime targets. Static libraries are always  treated
	      as  archive  targets.  Module  libraries	are  always treated as
	      library targets. For  non-DLL  platforms	shared	libraries  are
	      treated  as library targets. For DLL platforms the DLL part of a
	      shared library is treated as a runtime  target  and  the	corre‐
	      sponding	import	library	 is  treated as an archive target. All
	      Windows-based systems including Cygwin are DLL platforms.	  This
	      property	is  initialized by the value of the variable CMAKE_AR‐
	      CHIVE_OUTPUT_DIRECTORY if it is set when a target is created.

       ARCHIVE_OUTPUT_DIRECTORY_<CONFIG>
	      Per-configuration output directory for ARCHIVE target files.

	      This is a per-configuration version of ARCHIVE_OUTPUT_DIRECTORY,
	      but  multi-configuration	generators (VS, Xcode) do NOT append a
	      per-configuration subdirectory to the specified directory.  This
	      property	is  initialized by the value of the variable CMAKE_AR‐
	      CHIVE_OUTPUT_DIRECTORY_<CONFIG> if it is set when	 a  target  is
	      created.

       ARCHIVE_OUTPUT_NAME
	      Output name for ARCHIVE target files.

	      This  property specifies the base name for archive target files.
	      It overrides OUTPUT_NAME	and  OUTPUT_NAME_<CONFIG>  properties.
	      There  are  three	 kinds	of target files that may be built: ar‐
	      chive, library, and runtime.  Executables are always treated  as
	      runtime  targets. Static libraries are always treated as archive
	      targets. Module libraries are always treated as library targets.
	      For  non-DLL  platforms  shared libraries are treated as library
	      targets. For DLL platforms the DLL part of a shared  library  is
	      treated as a runtime target and the corresponding import library
	      is treated as  an	 archive  target.  All	Windows-based  systems
	      including Cygwin are DLL platforms.

       ARCHIVE_OUTPUT_NAME_<CONFIG>
	      Per-configuration output name for ARCHIVE target files.

	      This  is	the  configuration-specific  version  of  ARCHIVE_OUT‐
	      PUT_NAME.

       AUTOMOC
	      Should the target be processed with automoc (for Qt projects).

	      AUTOMOC is a boolean specifying whether CMake will handle the Qt
	      moc  preprocessor	 automatically, i.e. without having to use the
	      QT4_WRAP_CPP() or QT5_WRAP_CPP() macro. Currently	 Qt4  and  Qt5
	      are  supported.	When  this property is set to TRUE, CMake will
	      scan the source files at build time and invoke moc  accordingly.
	      If  an  #include statement like #include "moc_foo.cpp" is found,
	      the Q_OBJECT class declaration is expected in  the  header,  and
	      moc  is  run  on	the header file. If an #include statement like
	      #include "foo.moc" is found, then a Q_OBJECT is expected in  the
	      current source file and moc is run on the file itself. Addition‐
	      ally, all header files are parsed for Q_OBJECT  macros,  and  if
	      found,  moc  is  also executed on those files. The resulting moc
	      files, which are not included as	shown  above  in  any  of  the
	      source  files  are  included  in	a generated <targetname>_auto‐
	      moc.cpp file, which is compiled as part of the target.This prop‐
	      erty  is	initialized by the value of the variable CMAKE_AUTOMOC
	      if it is set when a target is created.

	      Additional command line options for moc can be set via the AUTO‐
	      MOC_MOC_OPTIONS property.

	      By  setting  the CMAKE_AUTOMOC_RELAXED_MODE variable to TRUE the
	      rules for searching the files which will be processed by moc can
	      be  relaxed.  See	 the  documentation for this variable for more
	      details.

	      The global property AUTOMOC_TARGETS_FOLDER can be used to	 group
	      the automoc targets together in an IDE, e.g. in MSVS.

       AUTOMOC_MOC_OPTIONS
	      Additional  options  for moc when using automoc (see the AUTOMOC
	      property)

	      This property is only used if the AUTOMOC	 property  is  set  to
	      TRUE  for this target. In this case, it holds additional command
	      line options which will be used when moc is executed during  the
	      build, i.e. it is equivalent to the optional OPTIONS argument of
	      the qt4_wrap_cpp() macro.

	      By default it is empty.

       BUILD_WITH_INSTALL_RPATH
	      Should build tree targets have install tree rpaths.

	      BUILD_WITH_INSTALL_RPATH is a boolean specifying whether to link
	      the target in the build tree with the INSTALL_RPATH.  This takes
	      precedence over SKIP_BUILD_RPATH and avoids the need for relink‐
	      ing  before  installation.   This property is initialized by the
	      value of the variable CMAKE_BUILD_WITH_INSTALL_RPATH  if	it  is
	      set when a target is created.

       BUNDLE This target is a CFBundle on the Mac.

	      If a module library target has this property set to true it will
	      be built as a CFBundle when built on the mac. It will  have  the
	      directory structure required for a CFBundle and will be suitable
	      to be used for creating Browser  Plugins	or  other  application
	      resources.

       BUNDLE_EXTENSION
	      The file extension used to name a BUNDLE target on the Mac.

	      The  default  value  is  "bundle" - you can also use "plugin" or
	      whatever file extension is required by the  host	app  for  your
	      bundle.

       COMPATIBLE_INTERFACE_BOOL
	      Properties which must be compatible with their link interface

	      The  COMPATIBLE_INTERFACE_BOOL  property	may  contain a list of
	      propertiesfor this target which must be consistent  when	evalu‐
	      ated as a boolean in the INTERFACE of all linked dependees.  For
	      example, if a property "FOO" appears in the list, then for  each
	      dependee,	 the  "INTERFACE_FOO"  property	 content in all of its
	      dependencies must be consistent with each other,	and  with  the
	      "FOO"  property  in the dependee.	 Consistency in this sense has
	      the meaning that if the property is set, then it must  have  the
	      same  boolean  value  as	all others, and if the property is not
	      set, then it is ignored.	Note that for each dependee,  the  set
	      of properties from this property must not intersect with the set
	      of properties from the COMPATIBLE_INTERFACE_STRING property.

       COMPATIBLE_INTERFACE_STRING
	      Properties which	must  be  string-compatible  with  their  link
	      interface

	      The  COMPATIBLE_INTERFACE_STRING	property may contain a list of
	      properties for this target which must be the same when evaluated
	      as a string in the INTERFACE of all linked dependees.  For exam‐
	      ple, if a property "FOO" appears in  the	list,  then  for  each
	      dependee,	 the  "INTERFACE_FOO"  property	 content in all of its
	      dependencies must be equal with each other, and with  the	 "FOO"
	      property	in  the dependee.  If the property is not set, then it
	      is ignored.  Note that for each dependee, the set of  properties
	      from this property must not intersect with the set of properties
	      from the COMPATIBLE_INTERFACE_BOOL property.

       COMPILE_DEFINITIONS
	      Preprocessor definitions for compiling a target's sources.

	      The COMPILE_DEFINITIONS property may be set to a semicolon-sepa‐
	      rated  list  of preprocessor definitions using the syntax VAR or
	      VAR=value.  Function-style definitions are not supported.	 CMake
	      will  automatically  escape  the	value correctly for the native
	      build system  (note  that	 CMake	language  syntax  may  require
	      escapes  to specify some values).	 This property may be set on a
	      per-configuration basis using the name COMPILE_DEFINITIONS_<CON‐
	      FIG>  where <CONFIG> is an upper-case name (ex. "COMPILE_DEFINI‐
	      TIONS_DEBUG").

	      CMake will automatically drop some definitions that are not sup‐
	      ported  by  the native build tool.  The VS6 IDE does not support
	      definition values with spaces (but NMake does).

	      Contents of COMPILE_DEFINITIONS may use "generator  expressions"
	      with  the	 syntax "$<...>".  Generator expressions are evaluated
	      during build system generation to produce	 information  specific
	      to each build configuration.  Valid expressions are:

		$<0:...>		  = empty string (ignores "...")
		$<1:...>		  = content of "..."
		$<CONFIG:cfg>		  = '1' if config is "cfg", else '0'
		$<CONFIGURATION>	  = configuration name
		$<BOOL:...>		  = '1' if the '...' is true, else '0'
		$<STREQUAL:a,b>		  = '1' if a is STREQUAL b, else '0'
		$<ANGLE-R>		  = A literal '>'. Used to compare strings which contain a '>' for example.
		$<COMMA>		  = A literal ','. Used to compare strings which contain a ',' for example.
		$<SEMICOLON>		  = A literal ';'. Used to prevent list expansion on an argument with ';'.
		$<JOIN:list,...>	  = joins the list with the content of "..."
		$<TARGET_NAME:...>	  = Marks ... as being the name of a target.  This is required if exporting targets to multiple dependent export sets.	The '...' must be a literal name of a target- it may not contain generator expressions.
		$<INSTALL_INTERFACE:...>  = content of "..." when the property is exported using install(EXPORT), and empty otherwise.
		$<BUILD_INTERFACE:...>	  = content of "..." when the property is exported using export(), or when the target is used by another target in the same buildsystem. Expands to the empty string otherwise.
		$<C_COMPILER_ID>	  = The CMake-id of the C compiler used.
		$<C_COMPILER_ID:comp>	  = '1' if the CMake-id of the C compiler matches comp, otherwise '0'.
		$<CXX_COMPILER_ID>	  = The CMake-id of the CXX compiler used.
		$<CXX_COMPILER_ID:comp>	  = '1' if the CMake-id of the CXX compiler matches comp, otherwise '0'.
		$<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than v2, else '0'.
		$<VERSION_LESS:v1,v2>	  = '1' if v1 is a version less than v2, else '0'.
		$<VERSION_EQUAL:v1,v2>	  = '1' if v1 is the same version as v2, else '0'.
		$<C_COMPILER_VERSION>	  = The version of the C compiler used.
		$<C_COMPILER_VERSION:ver> = '1' if the version of the C compiler matches ver, otherwise '0'.
		$<CXX_COMPILER_VERSION>	  = The version of the CXX compiler used.
		$<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX compiler matches ver, otherwise '0'.
		$<TARGET_FILE:tgt>	  = main file (.exe, .so.1.2, .a)
		$<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)
		$<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)

	      where  "tgt"  is	the name of a target.  Target file expressions
	      produce a full path, but _DIR and _NAME versions can produce the
	      directory and file name components:

		$<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
		$<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
		$<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>

		$<TARGET_PROPERTY:tgt,prop>   = The value of the property prop on the target tgt.

	      Note  that  tgt  is not added as a dependency of the target this
	      expression is evaluated on.

		$<TARGET_POLICY:pol>	      = '1' if the policy was NEW when the 'head' target was created, else '0'.	 If the policy was not set, the warning message for the policy will be emitted.	 This generator expression only works for a subset of policies.
		$<INSTALL_PREFIX>	  = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise.

	      Boolean expressions:

		$<AND:?[,?]...>		  = '1' if all '?' are '1', else '0'
		$<OR:?[,?]...>		  = '0' if all '?' are '0', else '1'
		$<NOT:?>		  = '0' if '?' is '1', else '1'

	      where '?' is always either '0' or '1'.

	      Expressions with an implicit 'this' target:

		$<TARGET_PROPERTY:prop>	  = The value of the property prop on the target on which the generator expression is evaluated.

	      Disclaimer: Most native build tools have poor support for escap‐
	      ing  certain  values.  CMake has work-arounds for many cases but
	      some values may just not be possible to pass  correctly.	 If  a
	      value  does  not seem to be escaped correctly, do not attempt to
	      work-around the problem by adding escape sequences to the value.
	      Your work-around may break in a future version of CMake that has
	      improved escape support.	Instead consider defining the macro in
	      a	 (configured) header file.  Then report the limitation.	 Known
	      limitations include:

		#	   - broken almost everywhere
		;	   - broken in VS IDE 7.0 and Borland Makefiles
		,	   - broken in VS IDE
		%	   - broken in some cases in NMake
		& |	   - broken in some cases on MinGW
		^ < > \"   - broken in most Make tools on Windows

	      CMake does not reject these values outright because they do work
	      in some cases.  Use with caution.

       COMPILE_DEFINITIONS_<CONFIG>
	      Per-configuration preprocessor definitions on a target.

	      This  is	the  configuration-specific version of COMPILE_DEFINI‐
	      TIONS.

       COMPILE_FLAGS
	      Additional flags to use when compiling this target's sources.

	      The COMPILE_FLAGS property sets additional compiler  flags  used
	      to  build sources within the target.  Use COMPILE_DEFINITIONS to
	      pass additional preprocessor definitions.

       COMPILE_OPTIONS
	      List of options to pass to the compiler.

	      This property specifies the list of options specified so far for
	      this property.  This property exists on directories and targets.

	      The target property values are used by the generators to set the
	      options for the compiler.

	      Contents of COMPILE_OPTIONS may use "generator expressions" with
	      the syntax "$<...>".  Generator expressions are evaluated during
	      build system generation to produce information specific to  each
	      build configuration.  Valid expressions are:

		$<0:...>		  = empty string (ignores "...")
		$<1:...>		  = content of "..."
		$<CONFIG:cfg>		  = '1' if config is "cfg", else '0'
		$<CONFIGURATION>	  = configuration name
		$<BOOL:...>		  = '1' if the '...' is true, else '0'
		$<STREQUAL:a,b>		  = '1' if a is STREQUAL b, else '0'
		$<ANGLE-R>		  = A literal '>'. Used to compare strings which contain a '>' for example.
		$<COMMA>		  = A literal ','. Used to compare strings which contain a ',' for example.
		$<SEMICOLON>		  = A literal ';'. Used to prevent list expansion on an argument with ';'.
		$<JOIN:list,...>	  = joins the list with the content of "..."
		$<TARGET_NAME:...>	  = Marks ... as being the name of a target.  This is required if exporting targets to multiple dependent export sets.	The '...' must be a literal name of a target- it may not contain generator expressions.
		$<INSTALL_INTERFACE:...>  = content of "..." when the property is exported using install(EXPORT), and empty otherwise.
		$<BUILD_INTERFACE:...>	  = content of "..." when the property is exported using export(), or when the target is used by another target in the same buildsystem. Expands to the empty string otherwise.
		$<C_COMPILER_ID>	  = The CMake-id of the C compiler used.
		$<C_COMPILER_ID:comp>	  = '1' if the CMake-id of the C compiler matches comp, otherwise '0'.
		$<CXX_COMPILER_ID>	  = The CMake-id of the CXX compiler used.
		$<CXX_COMPILER_ID:comp>	  = '1' if the CMake-id of the CXX compiler matches comp, otherwise '0'.
		$<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than v2, else '0'.
		$<VERSION_LESS:v1,v2>	  = '1' if v1 is a version less than v2, else '0'.
		$<VERSION_EQUAL:v1,v2>	  = '1' if v1 is the same version as v2, else '0'.
		$<C_COMPILER_VERSION>	  = The version of the C compiler used.
		$<C_COMPILER_VERSION:ver> = '1' if the version of the C compiler matches ver, otherwise '0'.
		$<CXX_COMPILER_VERSION>	  = The version of the CXX compiler used.
		$<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX compiler matches ver, otherwise '0'.
		$<TARGET_FILE:tgt>	  = main file (.exe, .so.1.2, .a)
		$<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)
		$<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)

	      where  "tgt"  is	the name of a target.  Target file expressions
	      produce a full path, but _DIR and _NAME versions can produce the
	      directory and file name components:

		$<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
		$<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
		$<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>

		$<TARGET_PROPERTY:tgt,prop>   = The value of the property prop on the target tgt.

	      Note  that  tgt  is not added as a dependency of the target this
	      expression is evaluated on.

		$<TARGET_POLICY:pol>	      = '1' if the policy was NEW when the 'head' target was created, else '0'.	 If the policy was not set, the warning message for the policy will be emitted.	 This generator expression only works for a subset of policies.
		$<INSTALL_PREFIX>	  = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise.

	      Boolean expressions:

		$<AND:?[,?]...>		  = '1' if all '?' are '1', else '0'
		$<OR:?[,?]...>		  = '0' if all '?' are '0', else '1'
		$<NOT:?>		  = '0' if '?' is '1', else '1'

	      where '?' is always either '0' or '1'.

	      Expressions with an implicit 'this' target:

		$<TARGET_PROPERTY:prop>	  = The value of the property prop on the target on which the generator expression is evaluated.

       DEBUG_POSTFIX
	      See target property <CONFIG>_POSTFIX.

	      This property is	a  special  case  of  the  more-general	 <CON‐
	      FIG>_POSTFIX property for the DEBUG configuration.

       DEFINE_SYMBOL
	      Define a symbol when compiling this target's sources.

	      DEFINE_SYMBOL  sets  the name of the preprocessor symbol defined
	      when compiling sources in a shared library. If not set here then
	      it  is set to target_EXPORTS by default (with some substitutions
	      if the target is not a valid C identifier). This is  useful  for
	      headers  to  know	 whether  they	are being included from inside
	      their library or outside to properly  setup  dllexport/dllimport
	      decorations.

       ENABLE_EXPORTS
	      Specify  whether an executable exports symbols for loadable mod‐
	      ules.

	      Normally an executable does not export any symbols because it is
	      the  final  program.  It is possible for an executable to export
	      symbols to be used by loadable modules.  When this  property  is
	      set to true CMake will allow other targets to "link" to the exe‐
	      cutable with the TARGET_LINK_LIBRARIES command.	On  all	 plat‐
	      forms a target-level dependency on the executable is created for
	      targets that link to it.	For DLL platforms  an  import  library
	      will be created for the exported symbols and then used for link‐
	      ing.  All Windows-based systems including Cygwin are  DLL	 plat‐
	      forms.   For  non-DLL  platforms	that require all symbols to be
	      resolved at link time, such as Mac OS X, the module will	"link"
	      to the executable using a flag like "-bundle_loader".  For other
	      non-DLL platforms the link rule  is  simply  ignored  since  the
	      dynamic  loader  will automatically bind symbols when the module
	      is loaded.

       EXCLUDE_FROM_ALL
	      Exclude the target from the all target.

	      A property on a target that indicates if the target is  excluded
	      from  the	 default build target. If it is not, then with a Make‐
	      file for example typing make will cause this target to be built.
	      The  same	 concept applies to the default build of other genera‐
	      tors. Installing a target with EXCLUDE_FROM_ALL set to true  has
	      undefined behavior.

       EXCLUDE_FROM_DEFAULT_BUILD
	      Exclude target from "Build Solution".

	      This  property  is  only	used by Visual Studio generators 7 and
	      above. When set to TRUE, the target will not be built  when  you
	      press "Build Solution".

       EXCLUDE_FROM_DEFAULT_BUILD_<CONFIG>
	      Per-configuration	 version of target exclusion from "Build Solu‐
	      tion".

	      This    is     the     configuration-specific	version	    of
	      EXCLUDE_FROM_DEFAULT_BUILD.	  If	    the	       generic
	      EXCLUDE_FROM_DEFAULT_BUILD   is	also   set   on	  a    target,
	      EXCLUDE_FROM_DEFAULT_BUILD_<CONFIG> takes precedence in configu‐
	      rations for which it has a value.

       EXPORT_NAME
	      Exported name for target files.

	      This sets the name for the IMPORTED  target  generated  when  it
	      this target is is exported.  If not set, the logical target name
	      is used by default.

       EchoString
	      A message to be displayed when the target is built.

	      A message to display on some generators (such as makefiles) when
	      the target is built.

       FOLDER Set the folder name. Use to organize targets in an IDE.

	      Targets  with  no FOLDER property will appear as top level enti‐
	      ties in IDEs like Visual Studio. Targets with  the  same	FOLDER
	      property	value  will  appear  next to each other in a folder of
	      that  name.  To  nest  folders,  use  FOLDER  values   such   as
	      'GUI/Dialogs' with '/' characters separating folder levels.

       FRAMEWORK
	      This target is a framework on the Mac.

	      If a shared library target has this property set to true it will
	      be built as a framework when built on the mac. It will have  the
	      directory	 structure  required for a framework and will be suit‐
	      able to be used with the -framework option

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

	      This property tells CMake whether the Fortran source files in  a
	      target  use  fixed-format	 or  free-format.  CMake will pass the
	      corresponding format flag to the compiler.  Use the  source-spe‐
	      cific Fortran_FORMAT property to change the format of a specific
	      source file.  If the variable CMAKE_Fortran_FORMAT is set when a
	      target is created its value is used to initialize this property.

       Fortran_MODULE_DIRECTORY
	      Specify  output  directory  for  Fortran modules provided by the
	      target.

	      If the target contains Fortran source files that provide modules
	      and  the compiler supports a module output directory this speci‐
	      fies the directory in which the modules will  be	placed.	  When
	      this property is not set the modules will be placed in the build
	      directory corresponding to the target's  source  directory.   If
	      the variable CMAKE_Fortran_MODULE_DIRECTORY is set when a target
	      is created its value is used to initialize this property.

	      Note that some compilers will automatically  search  the	module
	      output  directory for modules USEd during compilation but others
	      will not.	 If your sources USE modules their  location  must  be
	      specified by INCLUDE_DIRECTORIES regardless of this property.

       GENERATOR_FILE_NAME
	      Generator's file for this target.

	      An  internal property used by some generators to record the name
	      of the project or dsp file associated  with  this	 target.  Note
	      that  at	configure  time, this property is only set for targets
	      created by include_external_msproject().

       GNUtoMS
	      Convert GNU import library (.dll.a) to MS format (.lib).

	      When linking a shared library or executable that exports symbols
	      using  GNU  tools	 on  Windows  (MinGW/MSYS)  with Visual Studio
	      installed convert the import library (.dll.a)  from  GNU	to  MS
	      format  (.lib).	Both  import  libraries	 will  be installed by
	      install(TARGETS) and exported by install(EXPORT) and export() to
	      be  linked  by  applications  with  either GNU- or MS-compatible
	      tools.

	      If the variable CMAKE_GNUtoMS is set when a  target  is  created
	      its  value  is  used  to initialize this property.  The variable
	      must be set prior to the first command that enables  a  language
	      such  as	project()  or  enable_language().   CMake provides the
	      variable as an option to the user automatically when configuring
	      on Windows with GNU tools.

       HAS_CXX
	      Link the target using the C++ linker tool (obsolete).

	      This  is	equivalent  to setting the LINKER_LANGUAGE property to
	      CXX.  See that property's documentation for details.

       IMPLICIT_DEPENDS_INCLUDE_TRANSFORM
	      Specify #include line transforms for dependencies in a target.

	      This property specifies rules to transform  macro-like  #include
	      lines  during  implicit  dependency scanning of C and C++ source
	      files.  The list of rules must be semicolon-separated with  each
	      entry  of the form "A_MACRO(%)=value-with-%" (the % must be lit‐
	      eral).  During dependency scanning occurrences  of  A_MACRO(...)
	      on  #include  lines will be replaced by the value given with the
	      macro argument substituted for '%'.  For example, the entry

		MYDIR(%)=<mydir/%>

	      will convert lines of the form

		#include MYDIR(myheader.h)

	      to

		#include <mydir/myheader.h>

	      allowing the dependency to be followed.

	      This property applies to sources in the target on	 which	it  is
	      set.

       IMPORTED
	      Read-only indication of whether a target is IMPORTED.

	      The  boolean  value of this property is true for targets created
	      with the IMPORTED option to add_executable or  add_library.   It
	      is false for targets built within the project.

       IMPORTED_CONFIGURATIONS
	      Configurations provided for an IMPORTED target.

	      Set  this	 to  the  list of configuration names available for an
	      IMPORTED target.	The names correspond to configurations defined
	      in  the  project	from  which  the  target  is imported.	If the
	      importing project uses a different  set  of  configurations  the
	      names may be mapped using the MAP_IMPORTED_CONFIG_<CONFIG> prop‐
	      erty.  Ignored for non-imported targets.

       IMPORTED_IMPLIB
	      Full path to the import library for an IMPORTED target.

	      Set this to the location of the ".lib" part of  a	 windows  DLL.
	      Ignored for non-imported targets.

       IMPORTED_IMPLIB_<CONFIG>
	      <CONFIG>-specific version of IMPORTED_IMPLIB property.

	      Configuration  names correspond to those provided by the project
	      from which the target is imported.

       IMPORTED_LINK_DEPENDENT_LIBRARIES
	      Dependent shared libraries of an imported shared library.

	      Shared libraries may be linked to other shared libraries as part
	      of  their implementation.	 On some platforms the linker searches
	      for the dependent libraries of shared libraries they are includ‐
	      ing  in  the  link.   Set this property to the list of dependent
	      shared libraries of an imported library.	 The  list  should  be
	      disjoint	from  the  list	 of  interface libraries in the INTER‐
	      FACE_LINK_LIBRARIES property.  On platforms requiring  dependent
	      shared  libraries	 to be found at link time CMake uses this list
	      to add appropriate files or paths	 to  the  link	command	 line.
	      Ignored for non-imported targets.

       IMPORTED_LINK_DEPENDENT_LIBRARIES_<CONFIG>
	      <CONFIG>-specific version of IMPORTED_LINK_DEPENDENT_LIBRARIES.

	      Configuration  names correspond to those provided by the project
	      from which the target is imported.  If set, this	property  com‐
	      pletely  overrides the generic property for the named configura‐
	      tion.

       IMPORTED_LINK_INTERFACE_LANGUAGES
	      Languages compiled into an IMPORTED static library.

	      Set this to the list of languages of source  files  compiled  to
	      produce a STATIC IMPORTED library (such as "C" or "CXX").	 CMake
	      accounts for these languages when computing how to link a target
	      to the imported library.	For example, when a C executable links
	      to an imported C++ static library CMake chooses the  C++	linker
	      to satisfy language runtime dependencies of the static library.

	      This  property  is  ignored  for	targets	 that  are  not STATIC
	      libraries.  This property is ignored for non-imported targets.

       IMPORTED_LINK_INTERFACE_LANGUAGES_<CONFIG>
	      <CONFIG>-specific version of IMPORTED_LINK_INTERFACE_LANGUAGES.

	      Configuration names correspond to those provided by the  project
	      from  which  the target is imported.  If set, this property com‐
	      pletely overrides the generic property for the named  configura‐
	      tion.

       IMPORTED_LINK_INTERFACE_LIBRARIES
	      Transitive link interface of an IMPORTED target.

	      Set  this	 to  the list of libraries whose interface is included
	      when an IMPORTED library target is  linked  to  another  target.
	      The  libraries will be included on the link line for the target.
	      Unlike  the  LINK_INTERFACE_LIBRARIES  property,	this  property
	      applies	to   all   imported  target  types,  including	STATIC
	      libraries.  This property is ignored for non-imported targets.

	      This property is ignored if the  target  also  has  a  non-empty
	      INTERFACE_LINK_LIBRARIES property.

	      This   property	is  deprecated.	 Use  INTERFACE_LINK_LIBRARIES
	      instead.

       IMPORTED_LINK_INTERFACE_LIBRARIES_<CONFIG>
	      <CONFIG>-specific version of IMPORTED_LINK_INTERFACE_LIBRARIES.

	      Configuration names correspond to those provided by the  project
	      from  which  the target is imported.  If set, this property com‐
	      pletely overrides the generic property for the named  configura‐
	      tion.

	      This  property  is  ignored  if  the target also has a non-empty
	      INTERFACE_LINK_LIBRARIES property.

	      This  property  is  deprecated.	Use   INTERFACE_LINK_LIBRARIES
	      instead.

       IMPORTED_LINK_INTERFACE_MULTIPLICITY
	      Repetition count for cycles of IMPORTED static libraries.

	      This is LINK_INTERFACE_MULTIPLICITY for IMPORTED targets.

       IMPORTED_LINK_INTERFACE_MULTIPLICITY_<CONFIG>
	      <CONFIG>-specific	 version of IMPORTED_LINK_INTERFACE_MULTIPLIC‐
	      ITY.

	      If set, this property completely overrides the generic  property
	      for the named configuration.

       IMPORTED_LOCATION
	      Full path to the main file on disk for an IMPORTED target.

	      Set  this	 to  the  location of an IMPORTED target file on disk.
	      For executables this is the location  of	the  executable	 file.
	      For  bundles on OS X this is the location of the executable file
	      inside Contents/MacOS under the application bundle folder.   For
	      static libraries and modules this is the location of the library
	      or module.  For shared libraries on non-DLL  platforms  this  is
	      the location of the shared library.  For frameworks on OS X this
	      is the location of the library  file  symlink  just  inside  the
	      framework	 folder.   For DLLs this is the location of the ".dll"
	      part of the library.  For UNKNOWN libraries this is the location
	      of the file to be linked.	 Ignored for non-imported targets.

	      Projects	may  skip  IMPORTED_LOCATION if the configuration-spe‐
	      cific property IMPORTED_LOCATION_<CONFIG> is set.	  To  get  the
	      location of an imported target read one of the LOCATION or LOCA‐
	      TION_<CONFIG> properties.

       IMPORTED_LOCATION_<CONFIG>
	      <CONFIG>-specific version of IMPORTED_LOCATION property.

	      Configuration names correspond to those provided by the  project
	      from which the target is imported.

       IMPORTED_NO_SONAME
	      Specifies	 that  an  IMPORTED shared library target has no "son‐
	      ame".

	      Set this property to true for an imported	 shared	 library  file
	      that  has	 no  "soname"  field.  CMake may adjust generated link
	      commands for some platforms to prevent the linker from using the
	      path to the library in place of its missing soname.  Ignored for
	      non-imported targets.

       IMPORTED_NO_SONAME_<CONFIG>
	      <CONFIG>-specific version of IMPORTED_NO_SONAME property.

	      Configuration names correspond to those provided by the  project
	      from which the target is imported.

       IMPORTED_SONAME
	      The "soname" of an IMPORTED target of shared library type.

	      Set this to the "soname" embedded in an imported shared library.
	      This is meaningful only on  platforms  supporting	 the  feature.
	      Ignored for non-imported targets.

       IMPORTED_SONAME_<CONFIG>
	      <CONFIG>-specific version of IMPORTED_SONAME property.

	      Configuration  names correspond to those provided by the project
	      from which the target is imported.

       IMPORT_PREFIX
	      What comes before the import library name.

	      Similar to the target  property  PREFIX,	but  used  for	import
	      libraries	 (typically corresponding to a DLL) instead of regular
	      libraries. A target property that can be	set  to	 override  the
	      prefix (such as "lib") on an import library name.

       IMPORT_SUFFIX
	      What comes after the import library name.

	      Similar  to  the	target	property  SUFFIX,  but used for import
	      libraries (typically corresponding to a DLL) instead of  regular
	      libraries.  A  target  property  that can be set to override the
	      suffix (such as ".lib") on an import library name.

       INCLUDE_DIRECTORIES
	      List of preprocessor include file search directories.

	      This property specifies the list of directories given so far  to
	      the  include_directories command. This property exists on direc‐
	      tories and targets. In addition to  accepting  values  from  the
	      include_directories  command,  values may be set directly on any
	      directory or any target using the set_property command. A target
	      gets  its	 initial value for this property from the value of the
	      directory property. A directory gets its initial value from  its
	      parent  directory if it has one. Both directory and target prop‐
	      erty values are adjusted by  calls  to  the  include_directories
	      command.

	      The target property values are used by the generators to set the
	      include paths for the compiler.  See also	 the  include_directo‐
	      ries command.

	      Contents	of INCLUDE_DIRECTORIES may use "generator expressions"
	      with the syntax "$<...>".	 Generator expressions	are  evaluated
	      during  build  system generation to produce information specific
	      to each build configuration.  Valid expressions are:

		$<0:...>		  = empty string (ignores "...")
		$<1:...>		  = content of "..."
		$<CONFIG:cfg>		  = '1' if config is "cfg", else '0'
		$<CONFIGURATION>	  = configuration name
		$<BOOL:...>		  = '1' if the '...' is true, else '0'
		$<STREQUAL:a,b>		  = '1' if a is STREQUAL b, else '0'
		$<ANGLE-R>		  = A literal '>'. Used to compare strings which contain a '>' for example.
		$<COMMA>		  = A literal ','. Used to compare strings which contain a ',' for example.
		$<SEMICOLON>		  = A literal ';'. Used to prevent list expansion on an argument with ';'.
		$<JOIN:list,...>	  = joins the list with the content of "..."
		$<TARGET_NAME:...>	  = Marks ... as being the name of a target.  This is required if exporting targets to multiple dependent export sets.	The '...' must be a literal name of a target- it may not contain generator expressions.
		$<INSTALL_INTERFACE:...>  = content of "..." when the property is exported using install(EXPORT), and empty otherwise.
		$<BUILD_INTERFACE:...>	  = content of "..." when the property is exported using export(), or when the target is used by another target in the same buildsystem. Expands to the empty string otherwise.
		$<C_COMPILER_ID>	  = The CMake-id of the C compiler used.
		$<C_COMPILER_ID:comp>	  = '1' if the CMake-id of the C compiler matches comp, otherwise '0'.
		$<CXX_COMPILER_ID>	  = The CMake-id of the CXX compiler used.
		$<CXX_COMPILER_ID:comp>	  = '1' if the CMake-id of the CXX compiler matches comp, otherwise '0'.
		$<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than v2, else '0'.
		$<VERSION_LESS:v1,v2>	  = '1' if v1 is a version less than v2, else '0'.
		$<VERSION_EQUAL:v1,v2>	  = '1' if v1 is the same version as v2, else '0'.
		$<C_COMPILER_VERSION>	  = The version of the C compiler used.
		$<C_COMPILER_VERSION:ver> = '1' if the version of the C compiler matches ver, otherwise '0'.
		$<CXX_COMPILER_VERSION>	  = The version of the CXX compiler used.
		$<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX compiler matches ver, otherwise '0'.
		$<TARGET_FILE:tgt>	  = main file (.exe, .so.1.2, .a)
		$<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)
		$<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)

	      where "tgt" is the name of a target.   Target  file  expressions
	      produce a full path, but _DIR and _NAME versions can produce the
	      directory and file name components:

		$<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
		$<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
		$<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>

		$<TARGET_PROPERTY:tgt,prop>   = The value of the property prop on the target tgt.

	      Note that tgt is not added as a dependency of  the  target  this
	      expression is evaluated on.

		$<TARGET_POLICY:pol>	      = '1' if the policy was NEW when the 'head' target was created, else '0'.	 If the policy was not set, the warning message for the policy will be emitted.	 This generator expression only works for a subset of policies.
		$<INSTALL_PREFIX>	  = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise.

	      Boolean expressions:

		$<AND:?[,?]...>		  = '1' if all '?' are '1', else '0'
		$<OR:?[,?]...>		  = '0' if all '?' are '0', else '1'
		$<NOT:?>		  = '0' if '?' is '1', else '1'

	      where '?' is always either '0' or '1'.

	      Expressions with an implicit 'this' target:

		$<TARGET_PROPERTY:prop>	  = The value of the property prop on the target on which the generator expression is evaluated.

       INSTALL_NAME_DIR
	      Mac OSX directory name for installed targets.

	      INSTALL_NAME_DIR is a string specifying the directory portion of
	      the "install_name" field of shared libraries on Mac OSX  to  use
	      in the installed targets.

       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	 prop‐
	      erty   is	  initialized	by   the   value   of	the   variable
	      CMAKE_INSTALL_RPATH if it is set when a target is created.

       INSTALL_RPATH_USE_LINK_PATH
	      Add paths to linker search and installed rpath.

	      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 property is  initialized
	      by  the  value of the variable CMAKE_INSTALL_RPATH_USE_LINK_PATH
	      if it is set when a target is created.

       INTERFACE_COMPILE_DEFINITIONS
	      List of public compile definitions for a library.

	      Targets may populate this property to publish the compile	 defi‐
	      nitions  required to compile against the headers for the target.
	      Consuming targets can add entries to their  own  COMPILE_DEFINI‐
	      TIONS   property	such  as  $<TARGET_PROPERTY:foo,INTERFACE_COM‐
	      PILE_DEFINITIONS> to use the compile  definitions	 specified  in
	      the interface of 'foo'.

	      Generator	 expressions are evaluated during build system genera‐
	      tion to produce information specific to  each  build  configura‐
	      tion.  Valid expressions are:

		$<0:...>		  = empty string (ignores "...")
		$<1:...>		  = content of "..."
		$<CONFIG:cfg>		  = '1' if config is "cfg", else '0'
		$<CONFIGURATION>	  = configuration name
		$<BOOL:...>		  = '1' if the '...' is true, else '0'
		$<STREQUAL:a,b>		  = '1' if a is STREQUAL b, else '0'
		$<ANGLE-R>		  = A literal '>'. Used to compare strings which contain a '>' for example.
		$<COMMA>		  = A literal ','. Used to compare strings which contain a ',' for example.
		$<SEMICOLON>		  = A literal ';'. Used to prevent list expansion on an argument with ';'.
		$<JOIN:list,...>	  = joins the list with the content of "..."
		$<TARGET_NAME:...>	  = Marks ... as being the name of a target.  This is required if exporting targets to multiple dependent export sets.	The '...' must be a literal name of a target- it may not contain generator expressions.
		$<INSTALL_INTERFACE:...>  = content of "..." when the property is exported using install(EXPORT), and empty otherwise.
		$<BUILD_INTERFACE:...>	  = content of "..." when the property is exported using export(), or when the target is used by another target in the same buildsystem. Expands to the empty string otherwise.
		$<C_COMPILER_ID>	  = The CMake-id of the C compiler used.
		$<C_COMPILER_ID:comp>	  = '1' if the CMake-id of the C compiler matches comp, otherwise '0'.
		$<CXX_COMPILER_ID>	  = The CMake-id of the CXX compiler used.
		$<CXX_COMPILER_ID:comp>	  = '1' if the CMake-id of the CXX compiler matches comp, otherwise '0'.
		$<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than v2, else '0'.
		$<VERSION_LESS:v1,v2>	  = '1' if v1 is a version less than v2, else '0'.
		$<VERSION_EQUAL:v1,v2>	  = '1' if v1 is the same version as v2, else '0'.
		$<C_COMPILER_VERSION>	  = The version of the C compiler used.
		$<C_COMPILER_VERSION:ver> = '1' if the version of the C compiler matches ver, otherwise '0'.
		$<CXX_COMPILER_VERSION>	  = The version of the CXX compiler used.
		$<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX compiler matches ver, otherwise '0'.
		$<TARGET_FILE:tgt>	  = main file (.exe, .so.1.2, .a)
		$<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)
		$<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)

	      where  "tgt"  is	the name of a target.  Target file expressions
	      produce a full path, but _DIR and _NAME versions can produce the
	      directory and file name components:

		$<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
		$<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
		$<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>

		$<TARGET_PROPERTY:tgt,prop>   = The value of the property prop on the target tgt.

	      Note  that  tgt  is not added as a dependency of the target this
	      expression is evaluated on.

		$<TARGET_POLICY:pol>	      = '1' if the policy was NEW when the 'head' target was created, else '0'.	 If the policy was not set, the warning message for the policy will be emitted.	 This generator expression only works for a subset of policies.
		$<INSTALL_PREFIX>	  = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise.

	      Boolean expressions:

		$<AND:?[,?]...>		  = '1' if all '?' are '1', else '0'
		$<OR:?[,?]...>		  = '0' if all '?' are '0', else '1'
		$<NOT:?>		  = '0' if '?' is '1', else '1'

	      where '?' is always either '0' or '1'.

	      Expressions with an implicit 'this' target:

		$<TARGET_PROPERTY:prop>	  = The value of the property prop on the target on which the generator expression is evaluated.

       INTERFACE_COMPILE_OPTIONS
	      List of interface options to pass to the compiler.

	      Targets may  populate  this  property  to	 publish  the  compile
	      options  required to compile against the headers for the target.
	      Consuming targets can add entries to their  own  COMPILE_OPTIONS
	      property	   such	    as	  $<TARGET_PROPERTY:foo,INTERFACE_COM‐
	      PILE_OPTIONS> to use the compile options specified in the inter‐
	      face of 'foo'.

	      Generator	 expressions are evaluated during build system genera‐
	      tion to produce information specific to  each  build  configura‐
	      tion.  Valid expressions are:

		$<0:...>		  = empty string (ignores "...")
		$<1:...>		  = content of "..."
		$<CONFIG:cfg>		  = '1' if config is "cfg", else '0'
		$<CONFIGURATION>	  = configuration name
		$<BOOL:...>		  = '1' if the '...' is true, else '0'
		$<STREQUAL:a,b>		  = '1' if a is STREQUAL b, else '0'
		$<ANGLE-R>		  = A literal '>'. Used to compare strings which contain a '>' for example.
		$<COMMA>		  = A literal ','. Used to compare strings which contain a ',' for example.
		$<SEMICOLON>		  = A literal ';'. Used to prevent list expansion on an argument with ';'.
		$<JOIN:list,...>	  = joins the list with the content of "..."
		$<TARGET_NAME:...>	  = Marks ... as being the name of a target.  This is required if exporting targets to multiple dependent export sets.	The '...' must be a literal name of a target- it may not contain generator expressions.
		$<INSTALL_INTERFACE:...>  = content of "..." when the property is exported using install(EXPORT), and empty otherwise.
		$<BUILD_INTERFACE:...>	  = content of "..." when the property is exported using export(), or when the target is used by another target in the same buildsystem. Expands to the empty string otherwise.
		$<C_COMPILER_ID>	  = The CMake-id of the C compiler used.
		$<C_COMPILER_ID:comp>	  = '1' if the CMake-id of the C compiler matches comp, otherwise '0'.
		$<CXX_COMPILER_ID>	  = The CMake-id of the CXX compiler used.
		$<CXX_COMPILER_ID:comp>	  = '1' if the CMake-id of the CXX compiler matches comp, otherwise '0'.
		$<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than v2, else '0'.
		$<VERSION_LESS:v1,v2>	  = '1' if v1 is a version less than v2, else '0'.
		$<VERSION_EQUAL:v1,v2>	  = '1' if v1 is the same version as v2, else '0'.
		$<C_COMPILER_VERSION>	  = The version of the C compiler used.
		$<C_COMPILER_VERSION:ver> = '1' if the version of the C compiler matches ver, otherwise '0'.
		$<CXX_COMPILER_VERSION>	  = The version of the CXX compiler used.
		$<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX compiler matches ver, otherwise '0'.
		$<TARGET_FILE:tgt>	  = main file (.exe, .so.1.2, .a)
		$<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)
		$<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)

	      where  "tgt"  is	the name of a target.  Target file expressions
	      produce a full path, but _DIR and _NAME versions can produce the
	      directory and file name components:

		$<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
		$<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
		$<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>

		$<TARGET_PROPERTY:tgt,prop>   = The value of the property prop on the target tgt.

	      Note  that  tgt  is not added as a dependency of the target this
	      expression is evaluated on.

		$<TARGET_POLICY:pol>	      = '1' if the policy was NEW when the 'head' target was created, else '0'.	 If the policy was not set, the warning message for the policy will be emitted.	 This generator expression only works for a subset of policies.
		$<INSTALL_PREFIX>	  = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise.

	      Boolean expressions:

		$<AND:?[,?]...>		  = '1' if all '?' are '1', else '0'
		$<OR:?[,?]...>		  = '0' if all '?' are '0', else '1'
		$<NOT:?>		  = '0' if '?' is '1', else '1'

	      where '?' is always either '0' or '1'.

	      Expressions with an implicit 'this' target:

		$<TARGET_PROPERTY:prop>	  = The value of the property prop on the target on which the generator expression is evaluated.

       INTERFACE_INCLUDE_DIRECTORIES
	      List of public include directories for a library.

	      Targets may populate this property to publish the include direc‐
	      tories  required	to compile against the headers for the target.
	      Consuming targets can add entries to their own  INCLUDE_DIRECTO‐
	      RIES     property	    such    as	  $<TARGET_PROPERTY:foo,INTER‐
	      FACE_INCLUDE_DIRECTORIES> to use the include directories	speci‐
	      fied in the interface of 'foo'.

	      Generator	 expressions are evaluated during build system genera‐
	      tion to produce information specific to  each  build  configura‐
	      tion.  Valid expressions are:

		$<0:...>		  = empty string (ignores "...")
		$<1:...>		  = content of "..."
		$<CONFIG:cfg>		  = '1' if config is "cfg", else '0'
		$<CONFIGURATION>	  = configuration name
		$<BOOL:...>		  = '1' if the '...' is true, else '0'
		$<STREQUAL:a,b>		  = '1' if a is STREQUAL b, else '0'
		$<ANGLE-R>		  = A literal '>'. Used to compare strings which contain a '>' for example.
		$<COMMA>		  = A literal ','. Used to compare strings which contain a ',' for example.
		$<SEMICOLON>		  = A literal ';'. Used to prevent list expansion on an argument with ';'.
		$<JOIN:list,...>	  = joins the list with the content of "..."
		$<TARGET_NAME:...>	  = Marks ... as being the name of a target.  This is required if exporting targets to multiple dependent export sets.	The '...' must be a literal name of a target- it may not contain generator expressions.
		$<INSTALL_INTERFACE:...>  = content of "..." when the property is exported using install(EXPORT), and empty otherwise.
		$<BUILD_INTERFACE:...>	  = content of "..." when the property is exported using export(), or when the target is used by another target in the same buildsystem. Expands to the empty string otherwise.
		$<C_COMPILER_ID>	  = The CMake-id of the C compiler used.
		$<C_COMPILER_ID:comp>	  = '1' if the CMake-id of the C compiler matches comp, otherwise '0'.
		$<CXX_COMPILER_ID>	  = The CMake-id of the CXX compiler used.
		$<CXX_COMPILER_ID:comp>	  = '1' if the CMake-id of the CXX compiler matches comp, otherwise '0'.
		$<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than v2, else '0'.
		$<VERSION_LESS:v1,v2>	  = '1' if v1 is a version less than v2, else '0'.
		$<VERSION_EQUAL:v1,v2>	  = '1' if v1 is the same version as v2, else '0'.
		$<C_COMPILER_VERSION>	  = The version of the C compiler used.
		$<C_COMPILER_VERSION:ver> = '1' if the version of the C compiler matches ver, otherwise '0'.
		$<CXX_COMPILER_VERSION>	  = The version of the CXX compiler used.
		$<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX compiler matches ver, otherwise '0'.
		$<TARGET_FILE:tgt>	  = main file (.exe, .so.1.2, .a)
		$<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)
		$<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)

	      where  "tgt"  is	the name of a target.  Target file expressions
	      produce a full path, but _DIR and _NAME versions can produce the
	      directory and file name components:

		$<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
		$<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
		$<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>

		$<TARGET_PROPERTY:tgt,prop>   = The value of the property prop on the target tgt.

	      Note  that  tgt  is not added as a dependency of the target this
	      expression is evaluated on.

		$<TARGET_POLICY:pol>	      = '1' if the policy was NEW when the 'head' target was created, else '0'.	 If the policy was not set, the warning message for the policy will be emitted.	 This generator expression only works for a subset of policies.
		$<INSTALL_PREFIX>	  = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise.

	      Boolean expressions:

		$<AND:?[,?]...>		  = '1' if all '?' are '1', else '0'
		$<OR:?[,?]...>		  = '0' if all '?' are '0', else '1'
		$<NOT:?>		  = '0' if '?' is '1', else '1'

	      where '?' is always either '0' or '1'.

	      Expressions with an implicit 'this' target:

		$<TARGET_PROPERTY:prop>	  = The value of the property prop on the target on which the generator expression is evaluated.

       INTERFACE_LINK_LIBRARIES
	      List public interface libraries for a library.

	      This property contains the list of transitive link dependencies.
	      When  the	 target	 is  linked  into another target the libraries
	      listed (and recursively their link interface libraries) will  be
	      provided	to the other target also.  This property is overridden
	      by     the     LINK_INTERFACE_LIBRARIES	   or	   LINK_INTER‐
	      FACE_LIBRARIES_<CONFIG>  property	 if  policy  CMP0022 is OLD or
	      unset.

	      Generator expressions are evaluated during build system  genera‐
	      tion  to	produce	 information specific to each build configura‐
	      tion.  Valid expressions are:

		$<0:...>		  = empty string (ignores "...")
		$<1:...>		  = content of "..."
		$<CONFIG:cfg>		  = '1' if config is "cfg", else '0'
		$<CONFIGURATION>	  = configuration name
		$<BOOL:...>		  = '1' if the '...' is true, else '0'
		$<STREQUAL:a,b>		  = '1' if a is STREQUAL b, else '0'
		$<ANGLE-R>		  = A literal '>'. Used to compare strings which contain a '>' for example.
		$<COMMA>		  = A literal ','. Used to compare strings which contain a ',' for example.
		$<SEMICOLON>		  = A literal ';'. Used to prevent list expansion on an argument with ';'.
		$<JOIN:list,...>	  = joins the list with the content of "..."
		$<TARGET_NAME:...>	  = Marks ... as being the name of a target.  This is required if exporting targets to multiple dependent export sets.	The '...' must be a literal name of a target- it may not contain generator expressions.
		$<INSTALL_INTERFACE:...>  = content of "..." when the property is exported using install(EXPORT), and empty otherwise.
		$<BUILD_INTERFACE:...>	  = content of "..." when the property is exported using export(), or when the target is used by another target in the same buildsystem. Expands to the empty string otherwise.
		$<C_COMPILER_ID>	  = The CMake-id of the C compiler used.
		$<C_COMPILER_ID:comp>	  = '1' if the CMake-id of the C compiler matches comp, otherwise '0'.
		$<CXX_COMPILER_ID>	  = The CMake-id of the CXX compiler used.
		$<CXX_COMPILER_ID:comp>	  = '1' if the CMake-id of the CXX compiler matches comp, otherwise '0'.
		$<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than v2, else '0'.
		$<VERSION_LESS:v1,v2>	  = '1' if v1 is a version less than v2, else '0'.
		$<VERSION_EQUAL:v1,v2>	  = '1' if v1 is the same version as v2, else '0'.
		$<C_COMPILER_VERSION>	  = The version of the C compiler used.
		$<C_COMPILER_VERSION:ver> = '1' if the version of the C compiler matches ver, otherwise '0'.
		$<CXX_COMPILER_VERSION>	  = The version of the CXX compiler used.
		$<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX compiler matches ver, otherwise '0'.
		$<TARGET_FILE:tgt>	  = main file (.exe, .so.1.2, .a)
		$<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)
		$<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)

	      where "tgt" is the name of a target.   Target  file  expressions
	      produce a full path, but _DIR and _NAME versions can produce the
	      directory and file name components:

		$<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
		$<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
		$<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>

		$<TARGET_PROPERTY:tgt,prop>   = The value of the property prop on the target tgt.

	      Note that tgt is not added as a dependency of  the  target  this
	      expression is evaluated on.

		$<TARGET_POLICY:pol>	      = '1' if the policy was NEW when the 'head' target was created, else '0'.	 If the policy was not set, the warning message for the policy will be emitted.	 This generator expression only works for a subset of policies.
		$<INSTALL_PREFIX>	  = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise.

	      Boolean expressions:

		$<AND:?[,?]...>		  = '1' if all '?' are '1', else '0'
		$<OR:?[,?]...>		  = '0' if all '?' are '0', else '1'
		$<NOT:?>		  = '0' if '?' is '1', else '1'

	      where '?' is always either '0' or '1'.

	      Expressions with an implicit 'this' target:

		$<TARGET_PROPERTY:prop>	  = The value of the property prop on the target on which the generator expression is evaluated.

       INTERFACE_POSITION_INDEPENDENT_CODE
	      Whether consumers need to create a position-independent target

	      The  INTERFACE_POSITION_INDEPENDENT_CODE	property  informs con‐
	      sumers of this target whether they must set their POSITION_INDE‐
	      PENDENT_CODE  property  to  ON.	If this property is set to ON,
	      then the POSITION_INDEPENDENT_CODE  property  on	all  consumers
	      will  be	set to ON.  Similarly, if this property is set to OFF,
	      then the POSITION_INDEPENDENT_CODE  property  on	all  consumers
	      will  be	set  to OFF.  If this property is undefined, then con‐
	      sumers will determine their  POSITION_INDEPENDENT_CODE  property
	      by  other	 means.	  Consumers  must ensure that the targets that
	      they link to have a  consistent  requirement  for	 their	INTER‐
	      FACE_POSITION_INDEPENDENT_CODE property.

       INTERFACE_SYSTEM_INCLUDE_DIRECTORIES
	      List of public system include directories for a library.

	      Targets may populate this property to publish the include direc‐
	      tories which contain system headers, and	therefore  should  not
	      result  in  compiler warnings.  Consuming targets will then mark
	      the same include directories as system headers.

	      Generator expressions are evaluated during build system  genera‐
	      tion  to	produce	 information specific to each build configura‐
	      tion.  Valid expressions are:

		$<0:...>		  = empty string (ignores "...")
		$<1:...>		  = content of "..."
		$<CONFIG:cfg>		  = '1' if config is "cfg", else '0'
		$<CONFIGURATION>	  = configuration name
		$<BOOL:...>		  = '1' if the '...' is true, else '0'
		$<STREQUAL:a,b>		  = '1' if a is STREQUAL b, else '0'
		$<ANGLE-R>		  = A literal '>'. Used to compare strings which contain a '>' for example.
		$<COMMA>		  = A literal ','. Used to compare strings which contain a ',' for example.
		$<SEMICOLON>		  = A literal ';'. Used to prevent list expansion on an argument with ';'.
		$<JOIN:list,...>	  = joins the list with the content of "..."
		$<TARGET_NAME:...>	  = Marks ... as being the name of a target.  This is required if exporting targets to multiple dependent export sets.	The '...' must be a literal name of a target- it may not contain generator expressions.
		$<INSTALL_INTERFACE:...>  = content of "..." when the property is exported using install(EXPORT), and empty otherwise.
		$<BUILD_INTERFACE:...>	  = content of "..." when the property is exported using export(), or when the target is used by another target in the same buildsystem. Expands to the empty string otherwise.
		$<C_COMPILER_ID>	  = The CMake-id of the C compiler used.
		$<C_COMPILER_ID:comp>	  = '1' if the CMake-id of the C compiler matches comp, otherwise '0'.
		$<CXX_COMPILER_ID>	  = The CMake-id of the CXX compiler used.
		$<CXX_COMPILER_ID:comp>	  = '1' if the CMake-id of the CXX compiler matches comp, otherwise '0'.
		$<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than v2, else '0'.
		$<VERSION_LESS:v1,v2>	  = '1' if v1 is a version less than v2, else '0'.
		$<VERSION_EQUAL:v1,v2>	  = '1' if v1 is the same version as v2, else '0'.
		$<C_COMPILER_VERSION>	  = The version of the C compiler used.
		$<C_COMPILER_VERSION:ver> = '1' if the version of the C compiler matches ver, otherwise '0'.
		$<CXX_COMPILER_VERSION>	  = The version of the CXX compiler used.
		$<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX compiler matches ver, otherwise '0'.
		$<TARGET_FILE:tgt>	  = main file (.exe, .so.1.2, .a)
		$<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)
		$<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)

	      where "tgt" is the name of a target.   Target  file  expressions
	      produce a full path, but _DIR and _NAME versions can produce the
	      directory and file name components:

		$<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
		$<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
		$<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>

		$<TARGET_PROPERTY:tgt,prop>   = The value of the property prop on the target tgt.

	      Note that tgt is not added as a dependency of  the  target  this
	      expression is evaluated on.

		$<TARGET_POLICY:pol>	      = '1' if the policy was NEW when the 'head' target was created, else '0'.	 If the policy was not set, the warning message for the policy will be emitted.	 This generator expression only works for a subset of policies.
		$<INSTALL_PREFIX>	  = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise.

	      Boolean expressions:

		$<AND:?[,?]...>		  = '1' if all '?' are '1', else '0'
		$<OR:?[,?]...>		  = '0' if all '?' are '0', else '1'
		$<NOT:?>		  = '0' if '?' is '1', else '1'

	      where '?' is always either '0' or '1'.

	      Expressions with an implicit 'this' target:

		$<TARGET_PROPERTY:prop>	  = The value of the property prop on the target on which the generator expression is evaluated.

       INTERPROCEDURAL_OPTIMIZATION
	      Enable interprocedural optimization for a target.

	      If  set  to  true, enables interprocedural optimizations if they
	      are known to be supported by the compiler.

       INTERPROCEDURAL_OPTIMIZATION_<CONFIG>
	      Per-configuration interprocedural optimization for a target.

	      This is a per-configuration version of INTERPROCEDURAL_OPTIMIZA‐
	      TION.   If set, this property overrides the generic property for
	      the named configuration.

       LABELS Specify a list of text labels associated with a target.

	      Target label semantics are currently unspecified.

       LIBRARY_OUTPUT_DIRECTORY
	      Output directory in which to build LIBRARY target files.

	      This property specifies the directory into which library	target
	      files  should  be	 built.	 Multi-configuration  generators  (VS,
	      Xcode) append a per-configuration subdirectory to the  specified
	      directory.   There  are  three kinds of target files that may be
	      built: archive, library, and runtime.   Executables  are	always
	      treated  as runtime targets. Static libraries are always treated
	      as archive targets.  Module  libraries  are  always  treated  as
	      library  targets.	 For  non-DLL  platforms  shared libraries are
	      treated as library targets. For DLL platforms the DLL part of  a
	      shared  library  is  treated  as a runtime target and the corre‐
	      sponding import library is treated as  an	 archive  target.  All
	      Windows-based  systems including Cygwin are DLL platforms.  This
	      property	is  initialized	 by  the   value   of	the   variable
	      CMAKE_LIBRARY_OUTPUT_DIRECTORY  if  it  is  set when a target is
	      created.

       LIBRARY_OUTPUT_DIRECTORY_<CONFIG>
	      Per-configuration output directory for LIBRARY target files.

	      This is a per-configuration version of LIBRARY_OUTPUT_DIRECTORY,
	      but  multi-configuration	generators (VS, Xcode) do NOT append a
	      per-configuration subdirectory to the specified directory.  This
	      property	 is   initialized   by	 the  value  of	 the  variable
	      CMAKE_LIBRARY_OUTPUT_DIRECTORY_<CONFIG> if it is set when a tar‐
	      get is created.

       LIBRARY_OUTPUT_NAME
	      Output name for LIBRARY target files.

	      This  property specifies the base name for library target files.
	      It overrides OUTPUT_NAME	and  OUTPUT_NAME_<CONFIG>  properties.
	      There  are  three	 kinds	of target files that may be built: ar‐
	      chive, library, and runtime.  Executables are always treated  as
	      runtime  targets. Static libraries are always treated as archive
	      targets. Module libraries are always treated as library targets.
	      For  non-DLL  platforms  shared libraries are treated as library
	      targets. For DLL platforms the DLL part of a shared  library  is
	      treated as a runtime target and the corresponding import library
	      is treated as  an	 archive  target.  All	Windows-based  systems
	      including Cygwin are DLL platforms.

       LIBRARY_OUTPUT_NAME_<CONFIG>
	      Per-configuration output name for LIBRARY target files.

	      This  is	the  configuration-specific  version  of  LIBRARY_OUT‐
	      PUT_NAME.

       LINKER_LANGUAGE
	      Specifies language whose compiler will invoke the linker.

	      For executables, shared libraries, and modules,  this  sets  the
	      language	whose compiler is used to link the target (such as "C"
	      or "CXX").  A typical value for an executable is the language of
	      the  source  file	 providing the program entry point (main).  If
	      not set, the language with the highest linker  preference	 value
	      is  the default.	See documentation of CMAKE_<LANG>_LINKER_PREF‐
	      ERENCE variables.

	      If this property is not set by the user, it will	be  calculated
	      at generate-time by CMake.

       LINK_DEPENDS
	      Additional files on which a target binary depends for linking.

	      Specifies	 a  semicolon-separated list of full-paths to files on
	      which the link rule for this target depends.  The target	binary
	      will be linked if any of the named files is newer than it.

	      This  property  is  ignored  by  non-Makefile generators.	 It is
	      intended to specify dependencies on "linker scripts" for	custom
	      Makefile link rules.

       LINK_DEPENDS_NO_SHARED
	      Do not depend on linked shared library files.

	      Set  this	 property  to true to tell CMake generators not to add
	      file-level dependencies on the shared library  files  linked  by
	      this  target.   Modification to the shared libraries will not be
	      sufficient to re-link this target.  Logical target-level	depen‐
	      dencies will not be affected so the linked shared libraries will
	      still be brought up to date before this target is built.

	      This property is	initialized  by	 the  value  of	 the  variable
	      CMAKE_LINK_DEPENDS_NO_SHARED  if it is set when a target is cre‐
	      ated.

       LINK_FLAGS
	      Additional flags to use when linking this target.

	      The LINK_FLAGS property can be used to add extra	flags  to  the
	      link  step of a target. LINK_FLAGS_<CONFIG> will add to the con‐
	      figuration <CONFIG>, for example,	 DEBUG,	 RELEASE,  MINSIZEREL,
	      RELWITHDEBINFO.

       LINK_FLAGS_<CONFIG>
	      Per-configuration linker flags for a target.

	      This is the configuration-specific version of LINK_FLAGS.

       LINK_INTERFACE_LIBRARIES
	      List  public  interface  libraries  for a shared library or exe‐
	      cutable.

	      By default linking to a shared library target transitively links
	      to  targets  with	 which	the library itself was linked.	For an
	      executable with exports (see  the	 ENABLE_EXPORTS	 property)  no
	      default  transitive  link	 dependencies are used.	 This property
	      replaces	the  default  transitive  link	dependencies  with  an
	      explicit	list.	When  the target is linked into another target
	      the libraries  listed  (and  recursively	their  link  interface
	      libraries)  will	be  provided to the other target also.	If the
	      list is empty then  no  transitive  link	dependencies  will  be
	      incorporated when this target is linked into another target even
	      if the default set is non-empty.	This property  is  initialized
	      by  the  value of the variable CMAKE_LINK_INTERFACE_LIBRARIES if
	      it is set when a target is created.  This	 property  is  ignored
	      for STATIC libraries.

	      This  property  is  overridden  by  the INTERFACE_LINK_LIBRARIES
	      property if policy CMP0022 is NEW.

	      This  property  is  deprecated.	Use   INTERFACE_LINK_LIBRARIES
	      instead.

       LINK_INTERFACE_LIBRARIES_<CONFIG>
	      Per-configuration	 list of public interface libraries for a tar‐
	      get.

	      This  is	the  configuration-specific  version  of   LINK_INTER‐
	      FACE_LIBRARIES.	If set, this property completely overrides the
	      generic property for the named configuration.

	      This property  is	 overridden  by	 the  INTERFACE_LINK_LIBRARIES
	      property if policy CMP0022 is NEW.

	      This   property	is  deprecated.	 Use  INTERFACE_LINK_LIBRARIES
	      instead.

       LINK_INTERFACE_MULTIPLICITY
	      Repetition count for STATIC libraries with cyclic dependencies.

	      When linking to a STATIC library target with cyclic dependencies
	      the  linker may need to scan more than once through the archives
	      in the strongly connected component  of  the  dependency	graph.
	      CMake  by	 default  constructs  the link line so that the linker
	      will scan through the component at least twice.	This  property
	      specifies	 the  minimum number of scans if it is larger than the
	      default.	CMake uses the largest value specified by  any	target
	      in a component.

       LINK_INTERFACE_MULTIPLICITY_<CONFIG>
	      Per-configuration	  repetition   count   for  cycles  of	STATIC
	      libraries.

	      This  is	the  configuration-specific  version  of   LINK_INTER‐
	      FACE_MULTIPLICITY.   If  set, this property completely overrides
	      the generic property for the named configuration.

       LINK_LIBRARIES
	      List of direct link dependencies.

	      This property specifies the list of libraries or	targets	 which
	      will  be	used for linking. In addition to accepting values from
	      the target_link_libraries command, values may be set directly on
	      any target using the set_property command.

	      The target property values are used by the generators to set the
	      link  libraries  for  the	  compiler.    See   also   the	  tar‐
	      get_link_libraries command.

	      Contents	of LINK_LIBRARIES may use "generator expressions" with
	      the syntax "$<...>".  Generator expressions are evaluated during
	      build  system generation to produce information specific to each
	      build configuration.  Valid expressions are:

		$<0:...>		  = empty string (ignores "...")
		$<1:...>		  = content of "..."
		$<CONFIG:cfg>		  = '1' if config is "cfg", else '0'
		$<CONFIGURATION>	  = configuration name
		$<BOOL:...>		  = '1' if the '...' is true, else '0'
		$<STREQUAL:a,b>		  = '1' if a is STREQUAL b, else '0'
		$<ANGLE-R>		  = A literal '>'. Used to compare strings which contain a '>' for example.
		$<COMMA>		  = A literal ','. Used to compare strings which contain a ',' for example.
		$<SEMICOLON>		  = A literal ';'. Used to prevent list expansion on an argument with ';'.
		$<JOIN:list,...>	  = joins the list with the content of "..."
		$<TARGET_NAME:...>	  = Marks ... as being the name of a target.  This is required if exporting targets to multiple dependent export sets.	The '...' must be a literal name of a target- it may not contain generator expressions.
		$<INSTALL_INTERFACE:...>  = content of "..." when the property is exported using install(EXPORT), and empty otherwise.
		$<BUILD_INTERFACE:...>	  = content of "..." when the property is exported using export(), or when the target is used by another target in the same buildsystem. Expands to the empty string otherwise.
		$<C_COMPILER_ID>	  = The CMake-id of the C compiler used.
		$<C_COMPILER_ID:comp>	  = '1' if the CMake-id of the C compiler matches comp, otherwise '0'.
		$<CXX_COMPILER_ID>	  = The CMake-id of the CXX compiler used.
		$<CXX_COMPILER_ID:comp>	  = '1' if the CMake-id of the CXX compiler matches comp, otherwise '0'.
		$<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than v2, else '0'.
		$<VERSION_LESS:v1,v2>	  = '1' if v1 is a version less than v2, else '0'.
		$<VERSION_EQUAL:v1,v2>	  = '1' if v1 is the same version as v2, else '0'.
		$<C_COMPILER_VERSION>	  = The version of the C compiler used.
		$<C_COMPILER_VERSION:ver> = '1' if the version of the C compiler matches ver, otherwise '0'.
		$<CXX_COMPILER_VERSION>	  = The version of the CXX compiler used.
		$<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX compiler matches ver, otherwise '0'.
		$<TARGET_FILE:tgt>	  = main file (.exe, .so.1.2, .a)
		$<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)
		$<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)

	      where "tgt" is the name of a target.   Target  file  expressions
	      produce a full path, but _DIR and _NAME versions can produce the
	      directory and file name components:

		$<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
		$<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
		$<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>

		$<TARGET_PROPERTY:tgt,prop>   = The value of the property prop on the target tgt.

	      Note that tgt is not added as a dependency of  the  target  this
	      expression is evaluated on.

		$<TARGET_POLICY:pol>	      = '1' if the policy was NEW when the 'head' target was created, else '0'.	 If the policy was not set, the warning message for the policy will be emitted.	 This generator expression only works for a subset of policies.
		$<INSTALL_PREFIX>	  = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise.

	      Boolean expressions:

		$<AND:?[,?]...>		  = '1' if all '?' are '1', else '0'
		$<OR:?[,?]...>		  = '0' if all '?' are '0', else '1'
		$<NOT:?>		  = '0' if '?' is '1', else '1'

	      where '?' is always either '0' or '1'.

	      Expressions with an implicit 'this' target:

		$<TARGET_PROPERTY:prop>	  = The value of the property prop on the target on which the generator expression is evaluated.

       LINK_SEARCH_END_STATIC
	      End a link line such that static system libraries are used.

	      Some  linkers support switches such as -Bstatic and -Bdynamic to
	      determine whether to use static or shared	 libraries  for	 -lXXX
	      options.	 CMake	uses  these  options  to set the link type for
	      libraries whose full paths are not known or (in some cases)  are
	      in implicit link directories for the platform.  By default CMake
	      adds an option at the end of the library list (if necessary)  to
	      set  the	linker	search	type  back to its starting type.  This
	      property switches the  final  linker  search  type  to  -Bstatic
	      regardless      of     how     it	    started.	  See	  also
	      LINK_SEARCH_START_STATIC.

       LINK_SEARCH_START_STATIC
	      Assume the linker looks for static libraries by default.

	      Some linkers support switches such as -Bstatic and -Bdynamic  to
	      determine	 whether  to  use static or shared libraries for -lXXX
	      options.	CMake uses these options to  set  the  link  type  for
	      libraries	 whose full paths are not known or (in some cases) are
	      in implicit link directories for the platform.  By  default  the
	      linker  search  type is assumed to be -Bdynamic at the beginning
	      of the library list.  This property switches the	assumption  to
	      -Bstatic.	  It  is  intended  for use when linking an executable
	      statically  (e.g.	 with  the  GNU	 -static  option).   See  also
	      LINK_SEARCH_END_STATIC.

       LOCATION
	      Read-only location of a target on disk.

	      For  an  imported	 target,  this	read-only property returns the
	      value of the LOCATION_<CONFIG> property for an unspecified  con‐
	      figuration <CONFIG> provided by the target.

	      For a non-imported target, this property is provided for compat‐
	      ibility with CMake 2.4 and below.	 It was meant to get the loca‐
	      tion  of	an executable target's output file for use in add_cus‐
	      tom_command.  The path may contain a build-system-specific  por‐
	      tion  that is replaced at build time with the configuration get‐
	      ting built (such as "$(ConfigurationName)" in VS). In CMake  2.6
	      and  above  add_custom_command automatically recognizes a target
	      name in its COMMAND and DEPENDS options and computes the	target
	      location.	  In  CMake  2.8.4 and above add_custom_command recog‐
	      nizes generator expressions to refer to  target  locations  any‐
	      where in the command.  Therefore this property is not needed for
	      creating custom commands.

	      Do not set properties that affect the location of a target after
	      reading  this  property.	 These	include properties whose names
	      match  "(RUNTIME|LIBRARY|ARCHIVE)_OUTPUT_(NAME|DIRECTORY)(_<CON‐
	      FIG>)?",	 "(IMPLIB_)?(PREFIX|SUFFIX)",	or  "LINKER_LANGUAGE".
	      Failure to follow this rule is  not  diagnosed  and  leaves  the
	      location of the target undefined.

       LOCATION_<CONFIG>
	      Read-only property providing a target location on disk.

	      A	 read-only  property that indicates where a target's main file
	      is located on disk for the configuration <CONFIG>.  The property
	      is defined only for library and executable targets.  An imported
	      target may provide a set of configurations different  from  that
	      of  the  importing  project.   By	 default  CMake	 looks	for an
	      exact-match but otherwise uses an arbitrary available configura‐
	      tion.   Use  the	MAP_IMPORTED_CONFIG_<CONFIG>  property	to map
	      imported configurations explicitly.

	      Do not set properties that affect the location of a target after
	      reading  this  property.	 These	include properties whose names
	      match  "(RUNTIME|LIBRARY|ARCHIVE)_OUTPUT_(NAME|DIRECTORY)(_<CON‐
	      FIG>)?",	 "(IMPLIB_)?(PREFIX|SUFFIX)",	or  "LINKER_LANGUAGE".
	      Failure to follow this rule is  not  diagnosed  and  leaves  the
	      location of the target undefined.

       MACOSX_BUNDLE
	      Build an executable as an application bundle on Mac OS X.

	      When  this  property is set to true the executable when built on
	      Mac OS X will be created as an application bundle.   This	 makes
	      it  a  GUI executable that can be launched from the Finder.  See
	      the MACOSX_BUNDLE_INFO_PLIST  target  property  for  information
	      about  creation  of the Info.plist file for the application bun‐
	      dle.  This property is initialized by the value of the  variable
	      CMAKE_MACOSX_BUNDLE if it is set when a target is created.

       MACOSX_BUNDLE_INFO_PLIST
	      Specify a custom Info.plist template for a Mac OS X App Bundle.

	      An executable target with MACOSX_BUNDLE enabled will be built as
	      an application bundle on Mac OS X.  By  default  its  Info.plist
	      file  is	created by configuring a template called MacOSXBundle‐
	      Info.plist.in located in the CMAKE_MODULE_PATH.	This  property
	      specifies	 an alternative template file name which may be a full
	      path.

	      The following target properties may be set to specify content to
	      be configured into the file:

		MACOSX_BUNDLE_INFO_STRING
		MACOSX_BUNDLE_ICON_FILE
		MACOSX_BUNDLE_GUI_IDENTIFIER
		MACOSX_BUNDLE_LONG_VERSION_STRING
		MACOSX_BUNDLE_BUNDLE_NAME
		MACOSX_BUNDLE_SHORT_VERSION_STRING
		MACOSX_BUNDLE_BUNDLE_VERSION
		MACOSX_BUNDLE_COPYRIGHT

	      CMake  variables	of the same name may be set to affect all tar‐
	      gets in a directory that do not have each specific property set.
	      If  a  custom Info.plist is specified by this property it may of
	      course hard-code all the settings instead of  using  the	target
	      properties.

       MACOSX_FRAMEWORK_INFO_PLIST
	      Specify a custom Info.plist template for a Mac OS X Framework.

	      A	 library  target  with	FRAMEWORK  enabled  will be built as a
	      framework on Mac OS X.  By default its Info.plist file  is  cre‐
	      ated   by	  configuring	a   template  called  MacOSXFramework‐
	      Info.plist.in located in the CMAKE_MODULE_PATH.	This  property
	      specifies	 an alternative template file name which may be a full
	      path.

	      The following target properties may be set to specify content to
	      be configured into the file:

		MACOSX_FRAMEWORK_ICON_FILE
		MACOSX_FRAMEWORK_IDENTIFIER
		MACOSX_FRAMEWORK_SHORT_VERSION_STRING
		MACOSX_FRAMEWORK_BUNDLE_VERSION

	      CMake  variables	of the same name may be set to affect all tar‐
	      gets in a directory that do not have each specific property set.
	      If  a  custom Info.plist is specified by this property it may of
	      course hard-code all the settings instead of  using  the	target
	      properties.

       MACOSX_RPATH
	      Whether to use rpaths on Mac OS X.

	      When  this  property  is	set  to true, the directory portion of
	      the"install_name" field of  shared  libraries  will  default  to
	      "@rpath".Runtime	paths  will also be embedded in binaries using
	      this target.This property is initialized by  the	value  of  the
	      variable	CMAKE_MACOSX_RPATH  if it is set when a target is cre‐
	      ated.

       MAP_IMPORTED_CONFIG_<CONFIG>
	      Map from project configuration to IMPORTED  target's  configura‐
	      tion.

	      Set  this	 to  the  list of configurations of an imported target
	      that may be used for the current project's  <CONFIG>  configura‐
	      tion.  Targets imported from another project may not provide the
	      same  set	 of  configuration  names  available  in  the  current
	      project.	 Setting  this property tells CMake what imported con‐
	      figurations are suitable for use when building the <CONFIG> con‐
	      figuration.   The	 first	configuration  in the list found to be
	      provided by the imported target is selected.  If	this  property
	      is  set  and  no matching configurations are available, then the
	      imported target is considered to be not found.  This property is
	      ignored for non-imported targets.

       NAME   Logical name for the target.

	      Read-only logical name for the target as used by CMake.

       NO_SONAME
	      Whether to set "soname" when linking a shared library or module.

	      Enable  this  boolean  property if a generated shared library or
	      module should not have "soname" set. Default is to set  "soname"
	      on all shared libraries and modules as long as the platform sup‐
	      ports it. Generally, use this property  only  for	 leaf  private
	      libraries	 or  plugins. If you use it on normal shared libraries
	      which other targets link against, on  some  platforms  a	linker
	      will  insert  a  full  path to the library (as specified at link
	      time) into the dynamic section of the dependent  binary.	There‐
	      fore,  once  installed,  dynamic	loader	may eventually fail to
	      locate the library for the binary.

       OSX_ARCHITECTURES
	      Target specific architectures for OS X.

	      The OSX_ARCHITECTURES property sets the target binary  architec‐
	      ture  for	 targets on OS X.  This property is initialized by the
	      value of the variable CMAKE_OSX_ARCHITECTURES if it is set  when
	      a	 target is created.  Use OSX_ARCHITECTURES_<CONFIG> to set the
	      binary architectures on a per-configuration basis.  <CONFIG>  is
	      an upper-case name (ex: "OSX_ARCHITECTURES_DEBUG").

       OSX_ARCHITECTURES_<CONFIG>
	      Per-configuration OS X binary architectures for a target.

	      This   property	is   the   configuration-specific  version  of
	      OSX_ARCHITECTURES.

       OUTPUT_NAME
	      Output name for target files.

	      This sets the base name for output files	created	 for  an  exe‐
	      cutable  or library target.  If not set, the logical target name
	      is used by default.

       OUTPUT_NAME_<CONFIG>
	      Per-configuration target file base name.

	      This is the configuration-specific version of OUTPUT_NAME.

       PDB_NAME
	      Output name for MS debug symbols .pdb file from linker.

	      Set the base name for debug symbols file	created	 for  an  exe‐
	      cutable  or shared library target.  If not set, the logical tar‐
	      get name is used by default.

	      This property is not implemented by the Visual Studio 6  genera‐
	      tor.

       PDB_NAME_<CONFIG>
	      Per-configuration name for MS debug symbols .pdb file.

	      This is the configuration-specific version of PDB_NAME.

	      This  property is not implemented by the Visual Studio 6 genera‐
	      tor.

       PDB_OUTPUT_DIRECTORY
	      Output directory for MS debug symbols .pdb file from linker.

	      This property specifies the directory into which	the  MS	 debug
	      symbols will be placed by the linker.  This property is initial‐
	      ized by the value of the variable CMAKE_PDB_OUTPUT_DIRECTORY  if
	      it is set when a target is created.

	      This  property is not implemented by the Visual Studio 6 genera‐
	      tor.

       PDB_OUTPUT_DIRECTORY_<CONFIG>
	      Per-configuration output directory for  MS  debug	 symbols  .pdb
	      files.

	      This is a per-configuration version of PDB_OUTPUT_DIRECTORY, but
	      multi-configuration generators  (VS,  Xcode)  do	NOT  append  a
	      per-configuration	 subdirectory to the specified directory. This
	      property	is  initialized	 by  the   value   of	the   variable
	      CMAKE_PDB_OUTPUT_DIRECTORY_<CONFIG>  if  it is set when a target
	      is created.

	      This property is not implemented by the Visual Studio 6  genera‐
	      tor.

       POSITION_INDEPENDENT_CODE
	      Whether to create a position-independent target

	      The  POSITION_INDEPENDENT_CODE property determines whether posi‐
	      tion independent executables or shared libraries	will  be  cre‐
	      ated.   This  property  is true by default for SHARED and MODULE
	      library targets and false otherwise.  This property is  initial‐
	      ized  by	the  value  of	the  variable  CMAKE_POSITION_INDEPEN‐
	      DENT_CODE if it is set when a target is created.

       POST_INSTALL_SCRIPT
	      Deprecated install support.

	      The PRE_INSTALL_SCRIPT and  POST_INSTALL_SCRIPT  properties  are
	      the  old	way  to	 specify CMake scripts to run before and after
	      installing  a  target.   They  are  used	only  when   the   old
	      INSTALL_TARGETS  command is used to install the target.  Use the
	      INSTALL command instead.

       PREFIX What comes before the library name.

	      A target property that can be set to override the	 prefix	 (such
	      as "lib") on a library name.

       PRE_INSTALL_SCRIPT
	      Deprecated install support.

	      The  PRE_INSTALL_SCRIPT  and  POST_INSTALL_SCRIPT properties are
	      the old way to specify CMake scripts to  run  before  and	 after
	      installing   a   target.	 They  are  used  only	when  the  old
	      INSTALL_TARGETS command is used to install the target.  Use  the
	      INSTALL command instead.

       PRIVATE_HEADER
	      Specify  private header files in a FRAMEWORK shared library tar‐
	      get.

	      Shared library targets marked with the FRAMEWORK property gener‐
	      ate  frameworks  on  OS  X  and normal shared libraries on other
	      platforms.  This property may be set to a list of	 header	 files
	      to  be  placed in the PrivateHeaders directory inside the frame‐
	      work folder.   On	 non-Apple  platforms  these  headers  may  be
	      installed	 using	the  PRIVATE_HEADER option to the install(TAR‐
	      GETS) command.

       PROJECT_LABEL
	      Change the name of a target in an IDE.

	      Can be used to change the name of the target in an IDE like Vis‐
	      ual Studio.

       PUBLIC_HEADER
	      Specify  public  header files in a FRAMEWORK shared library tar‐
	      get.

	      Shared library targets marked with the FRAMEWORK property gener‐
	      ate  frameworks  on  OS  X  and normal shared libraries on other
	      platforms.  This property may be set to a list of	 header	 files
	      to  be  placed  in  the  Headers	directory inside the framework
	      folder.  On non-Apple platforms these headers may	 be  installed
	      using the PUBLIC_HEADER option to the install(TARGETS) command.

       RESOURCE
	      Specify resource files in a FRAMEWORK shared library target.

	      Shared library targets marked with the FRAMEWORK property gener‐
	      ate frameworks on OS X and  normal  shared  libraries  on	 other
	      platforms.   This	 property  may be set to a list of files to be
	      placed in the Resources directory inside the  framework  folder.
	      On  non-Apple  platforms	these files may be installed using the
	      RESOURCE option to the install(TARGETS) command.

       RULE_LAUNCH_COMPILE
	      Specify a launcher for compile rules.

	      See the global property of the  same  name  for  details.	  This
	      overrides the global and directory property for a target.

       RULE_LAUNCH_CUSTOM
	      Specify a launcher for custom rules.

	      See  the	global	property  of  the same name for details.  This
	      overrides the global and directory property for a target.

       RULE_LAUNCH_LINK
	      Specify a launcher for link rules.

	      See the global property of the  same  name  for  details.	  This
	      overrides the global and directory property for a target.

       RUNTIME_OUTPUT_DIRECTORY
	      Output directory in which to build RUNTIME target files.

	      This  property specifies the directory into which runtime target
	      files  should  be	 built.	 Multi-configuration  generators  (VS,
	      Xcode)  append a per-configuration subdirectory to the specified
	      directory.  There are three kinds of target files	 that  may  be
	      built:  archive,	library,  and runtime.	Executables are always
	      treated as runtime targets. Static libraries are always  treated
	      as  archive  targets.  Module  libraries	are  always treated as
	      library targets. For  non-DLL  platforms	shared	libraries  are
	      treated  as library targets. For DLL platforms the DLL part of a
	      shared library is treated as a runtime  target  and  the	corre‐
	      sponding	import	library	 is  treated as an archive target. All
	      Windows-based systems including Cygwin are DLL platforms.	  This
	      property	is initialized by the value of the variable CMAKE_RUN‐
	      TIME_OUTPUT_DIRECTORY if it is set when a target is created.

       RUNTIME_OUTPUT_DIRECTORY_<CONFIG>
	      Per-configuration output directory for RUNTIME target files.

	      This is a per-configuration version of RUNTIME_OUTPUT_DIRECTORY,
	      but  multi-configuration	generators (VS, Xcode) do NOT append a
	      per-configuration subdirectory to the specified directory.  This
	      property	is initialized by the value of the variable CMAKE_RUN‐
	      TIME_OUTPUT_DIRECTORY_<CONFIG> if it is set  when	 a  target  is
	      created.

       RUNTIME_OUTPUT_NAME
	      Output name for RUNTIME target files.

	      This  property specifies the base name for runtime target files.
	      It overrides OUTPUT_NAME	and  OUTPUT_NAME_<CONFIG>  properties.
	      There  are  three	 kinds	of target files that may be built: ar‐
	      chive, library, and runtime.  Executables are always treated  as
	      runtime  targets. Static libraries are always treated as archive
	      targets. Module libraries are always treated as library targets.
	      For  non-DLL  platforms  shared libraries are treated as library
	      targets. For DLL platforms the DLL part of a shared  library  is
	      treated as a runtime target and the corresponding import library
	      is treated as  an	 archive  target.  All	Windows-based  systems
	      including Cygwin are DLL platforms.

       RUNTIME_OUTPUT_NAME_<CONFIG>
	      Per-configuration output name for RUNTIME target files.

	      This  is	the  configuration-specific  version  of  RUNTIME_OUT‐
	      PUT_NAME.

       SKIP_BUILD_RPATH
	      Should rpaths be used for the build tree.

	      SKIP_BUILD_RPATH is a boolean specifying whether to  skip	 auto‐
	      matic generation of an rpath allowing the target to run from the
	      build tree.  This property is initialized by the	value  of  the
	      variable	CMAKE_SKIP_BUILD_RPATH	if  it is set when a target is
	      created.

       SOURCES
	      Source names specified for a target.

	      Read-only list of sources specified for  a  target.   The	 names
	      returned	are suitable for passing to the set_source_files_prop‐
	      erties command.

       SOVERSION
	      What version number is this target.

	      For shared libraries VERSION and SOVERSION can be used to	 spec‐
	      ify  the build version and API version respectively. When build‐
	      ing or installing appropriate symlinks are created if the	 plat‐
	      form supports symlinks and the linker supports so-names. If only
	      one of both is specified the missing is assumed to have the same
	      version  number.	SOVERSION  is ignored if NO_SONAME property is
	      set. For shared libraries and executables on Windows the VERSION
	      attribute	 is  parsed to extract a "major.minor" version number.
	      These numbers are used as the image version of the binary.

       STATIC_LIBRARY_FLAGS
	      Extra flags to use when linking static libraries.

	      Extra flags to use when linking a static library.

       STATIC_LIBRARY_FLAGS_<CONFIG>
	      Per-configuration flags for creating a static library.

	      This    is     the     configuration-specific	version	    of
	      STATIC_LIBRARY_FLAGS.

       SUFFIX What comes after the target name.

	      A	 target	 property that can be set to override the suffix (such
	      as ".so" or ".exe") on the name of a  library,  module  or  exe‐
	      cutable.

       TYPE   The type of the target.

	      This  read-only  property	 can  be  used to test the type of the
	      given target. It will be one of STATIC_LIBRARY,  MODULE_LIBRARY,
	      SHARED_LIBRARY, EXECUTABLE or one of the internal target types.

       VERSION
	      What version number is this target.

	      For  shared libraries VERSION and SOVERSION can be used to spec‐
	      ify the build version and API version respectively. When	build‐
	      ing  or installing appropriate symlinks are created if the plat‐
	      form supports symlinks and the linker supports so-names. If only
	      one of both is specified the missing is assumed to have the same
	      version number. For executables VERSION can be used  to  specify
	      the  build version. When building or installing appropriate sym‐
	      links are created if the platform supports symlinks. For	shared
	      libraries	 and  executables  on Windows the VERSION attribute is
	      parsed to extract a "major.minor" version number. These  numbers
	      are used as the image version of the binary.

       VISIBILITY_INLINES_HIDDEN
	      Whether  to  add	a compile flag to hide symbols of inline func‐
	      tions

	      The VISIBILITY_INLINES_HIDDEN property determines whether a flag
	      for  hiding  symbols for inline functions. the value passed used
	      in a visibility related compile option, such  as	-fvisibility=.
	      This  property  only has an affect for libraries and executables
	      with exports.  This property is initialized by the value of  the
	      variable	CMAKE_VISIBILITY_INLINES_HIDDEN	 if  it	 is set when a
	      target is created.

       VS_DOTNET_REFERENCES
	      Visual Studio managed project .NET references

	      Adds one or more semicolon-delimited .NET references to a gener‐
	      ated  Visual  Studio  project.  For example, "System;System.Win‐
	      dows.Forms".

       VS_DOTNET_TARGET_FRAMEWORK_VERSION
	      Specify the .NET target framework version.

	      Used to specify the .NET target framework version	 for  C++/CLI.
	      For example, "v4.5".

       VS_GLOBAL_<variable>
	      Visual Studio project-specific global variable.

	      Tell  the	 Visual	 Studio	 generator  to set the global variable
	      '<variable>' to a given value in	the  generated	Visual	Studio
	      project.	Ignored on other generators. Qt integration works bet‐
	      ter if VS_GLOBAL_QtVersion is set to the	version	 FindQt4.cmake
	      found. For example, "4.7.3"

       VS_GLOBAL_KEYWORD
	      Visual Studio project keyword.

	      Sets  the	 "keyword"  attribute  for  a  generated Visual Studio
	      project. Defaults to "Win32Proj". You may wish to override  this
	      value  with "ManagedCProj", for example, in a Visual Studio man‐
	      aged C++ unit test project.

       VS_GLOBAL_PROJECT_TYPES
	      Visual Studio project type(s).

	      Can be set to one or more UUIDs recognized by Visual  Studio  to
	      indicate the type of project. This value is copied verbatim into
	      the generated project file. Example for a managed C++ unit test‐
	      ing project:

	       {3AC096D0-A1C2-E12C-1390-A8335801FDAB};{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}

	      UUIDs are semicolon-delimited.

       VS_GLOBAL_ROOTNAMESPACE
	      Visual Studio project root namespace.

	      Sets the "RootNamespace" attribute for a generated Visual Studio
	      project.	The attribute will be generated only if this is set.

       VS_KEYWORD
	      Visual Studio project keyword.

	      Can be set to change the visual studio keyword, for  example  Qt
	      integration works better if this is set to Qt4VSv1.0.

       VS_SCC_AUXPATH
	      Visual Studio Source Code Control Aux Path.

	      Can  be set to change the visual studio source code control aux‐
	      path property.

       VS_SCC_LOCALPATH
	      Visual Studio Source Code Control Local Path.

	      Can be set to change the visual studio source code control local
	      path property.

       VS_SCC_PROJECTNAME
	      Visual Studio Source Code Control Project.

	      Can  be  set  to	change	the  visual studio source code control
	      project name property.

       VS_SCC_PROVIDER
	      Visual Studio Source Code Control Provider.

	      Can be set to change  the	 visual	 studio	 source	 code  control
	      provider property.

       VS_WINRT_EXTENSIONS
	      Visual  Studio  project  C++/CX  language extensions for Windows
	      Runtime

	      Can be set to enable C++/CX language extensions.

       VS_WINRT_REFERENCES
	      Visual Studio project Windows Runtime Metadata references

	      Adds one or more semicolon-delimited WinRT references to a  gen‐
	      erated   Visual	Studio	project.  For  example,	 "Windows;Win‐
	      dows.UI.Core".

       WIN32_EXECUTABLE
	      Build an executable with a WinMain entry point on windows.

	      When this property is set to true the executable when linked  on
	      Windows  will be created with a WinMain() entry point instead of
	      just main().  This makes it a GUI executable instead of  a  con‐
	      sole application.	 See the CMAKE_MFC_FLAG variable documentation
	      to configure use of MFC for WinMain executables.	This  property
	      is  initialized  by  the	value of the variable CMAKE_WIN32_EXE‐
	      CUTABLE if it is set when a target is created.

       XCODE_ATTRIBUTE_<an-attribute>
	      Set Xcode target attributes directly.

	      Tell the Xcode generator to  set	'<an-attribute>'  to  a	 given
	      value  in the generated Xcode project.  Ignored on other genera‐
	      tors.

PROPERTIES ON TESTS
       ATTACHED_FILES
	      Attach a list of files to a dashboard submission.

	      Set this property to a list of files that will  be  encoded  and
	      submitted to the dashboard as an addition to the test result.

       ATTACHED_FILES_ON_FAIL
	      Attach  a	 list  of  files to a dashboard submission if the test
	      fails.

	      Same as ATTACHED_FILES, but these files will only be included if
	      the test does not pass.

       COST   Set  this to a floating point value. Tests in a test set will be
	      run in descending order of cost.

	      This property describes the cost of a test. You  can  explicitly
	      set this value; tests with higher COST values will run first.

       DEPENDS
	      Specifies	 that this test should only be run after the specified
	      list of tests.

	      Set this to a list of tests that must finish before this test is
	      run.

       ENVIRONMENT
	      Specify environment variables that should be defined for running
	      a test.

	      If set to a list of environment variables and values of the form
	      MYVAR=value  those  environment  variables will be defined while
	      running the test. The environment is restored  to	 its  previous
	      state after the test is done.

       FAIL_REGULAR_EXPRESSION
	      If  the  output  matches	this  regular expression the test will
	      fail.

	      If set, if the output matches one of specified  regular  expres‐
	      sions,  the  test will fail.For example: FAIL_REGULAR_EXPRESSION
	      "[^a-z]Error;ERROR;Failed"

       LABELS Specify a list of text labels associated with a test.

	      The list is reported in dashboard submissions.

       MEASUREMENT
	      Specify a CDASH measurement and value to be reported for a test.

	      If set to a name then that name will be reported to CDASH	 as  a
	      named  measurement  with	a  value  of 1. You may also specify a
	      value by setting MEASUREMENT to "measurement=value".

       PASS_REGULAR_EXPRESSION
	      The output must match this regular expression for	 the  test  to
	      pass.

	      If  set,	the  test output will be checked against the specified
	      regular expressions and at least one of the regular  expressions
	      has to match, otherwise the test will fail.

       PROCESSORS
	      How many process slots this test requires

	      Denotes  the  number  of processors that this test will require.
	      This is typically used for MPI tests, and should be used in con‐
	      junction with the ctest_test PARALLEL_LEVEL option.

       REQUIRED_FILES
	      List of files required to run the test.

	      If  set  to a list of files, the test will not be run unless all
	      of the files exist.

       RESOURCE_LOCK
	      Specify a list of resources that are locked by this test.

	      If multiple tests specify the same resource lock, they are guar‐
	      anteed not to run concurrently.

       RUN_SERIAL
	      Do not run this test in parallel with any other test.

	      Use  this	 option	 in  conjunction  with	the  ctest_test PARAL‐
	      LEL_LEVEL option to specify that this test should not be run  in
	      parallel with any other tests.

       TIMEOUT
	      How many seconds to allow for this test.

	      This property if set will limit a test to not take more than the
	      specified number of seconds to run. If it exceeds that the  test
	      process  will  be	 killed	 and ctest will move to the next test.
	      This setting takes precedence over CTEST_TESTING_TIMEOUT.

       WILL_FAIL
	      If set to true, this will invert the pass/fail flag of the test.

	      This property can be used for tests that are  expected  to  fail
	      and return a non zero return code.

       WORKING_DIRECTORY
	      The directory from which the test executable will be called.

	      If this is not set it is called from the directory the test exe‐
	      cutable is located in.

VARIABLES
       CPACK_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION
	      Ask CPack 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.  Some  CPack   generators,	  like
	      NSIS,enforce this internally. This variable triggers the defini‐
	      tion  ofCMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION  when	 CPack
	      runsVariables common to all CPack generators

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  DES‐
	      TINATION path.

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

       CMAKE_AUTOMOC_RELAXED_MODE
	      Switch between strict and relaxed automoc mode.

	      By default, automoc behaves exactly as described in the documen‐
	      tation  of  the  AUTOMOC	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 speci‐
	      fies 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  deprecated
	      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 on single-configuration generators.

	      This  statically	specifies what build type (configuration) will
	      be built in this build tree. Possible values are	empty,	Debug,
	      Release,	RelWithDebInfo	and MinSizeRel.	 This variable is only
	      meaningful to single-configuration generators (such as make  and
	      Ninja) i.e. those which choose a single configuration when CMake
	      runs to generate a build tree as opposed to  multi-configuration
	      generators  which	 offer	selection  of  the build configuration
	      within the generated build environment.  There are many per-con‐
	      fig   properties	 and   variables   (usually   following	 clean
	      SOME_VAR_<CONFIG>	    order      conventions),	  such	    as
	      CMAKE_C_FLAGS_<CONFIG>,	    specified	    as	    uppercase:
	      CMAKE_C_FLAGS_[DEBUG|RELEASE|RELWITHDEBINFO|MINSIZEREL].	   For
	      example,	in  a build tree configured to build type Debug, CMake
	      will see to having CMAKE_C_FLAGS_DEBUG settings get added to the
	      CMAKE_C_FLAGS settings.  See also CMAKE_CONFIGURATION_TYPES.

       CMAKE_COLOR_MAKEFILE
	      Enables color output when using the Makefile generator.

	      When  enabled, the generated Makefiles will produce colored out‐
	      put.  Default is ON.

       CMAKE_CONFIGURATION_TYPES
	      Specifies the available build types on multi-config generators.

	      This specifies what build types (configurations) will be	avail‐
	      able  such as Debug, Release, RelWithDebInfo etc.	 This has rea‐
	      sonable defaults on most platforms, but can be extended to  pro‐
	      vide  other  build types.	 See also CMAKE_BUILD_TYPE for details
	      of managing configuration data, and CMAKE_CFG_INTDIR.

       CMAKE_DEBUG_TARGET_PROPERTIES
	      Enables tracing output for target properties.

	      This variable can be populated with a list of properties to gen‐
	      erate  debug output for when evaluating target properties.  Cur‐
	      rently it can only be used when evaluating the  INCLUDE_DIRECTO‐
	      RIES, COMPILE_DEFINITIONS and COMPILE_OPTIONS target properties.
	      In that case, it outputs a backtrace for each entry in the  tar‐
	      get property.  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 dis‐
	      abled by setting the variable CMAKE_DISABLE_FIND_PACKAGE_<Packa‐
	      geName>  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.	Other‐
	      wise  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 that case it is recommended to remove the
	      cache variables for this package from the cache using the	 cache
	      editor or cmake -U

       CMAKE_ERROR_DEPRECATED
	      Whether to issue deprecation errors for macros and functions.

	      If TRUE, this can be used by macros and functions to issue fatal
	      errors when deprecated macros or functions are used.  This vari‐
	      able is FALSE by default.

       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-gen‐
	      erated cmake_install.cmake scripts. If one sets this variable to
	      ON  while	 running  the  script, it may get fatal error messages
	      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  trying  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	 (MOD‐
	      ULE,  CONFIG  or	NO_MODULE) and no Find<pkg>.cmake module is in
	      CMAKE_MODULE_PATH then CMake implicitly assumes that the	caller
	      intends to search for a package configuration file.  If no pack‐
	      age 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  mes‐
	      sage can be more specific.

	      Set CMAKE_FIND_PACKAGE_WARN_NO_MODULE to TRUE to tell find_pack‐
	      age 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 incompatible but possibly	 link‐
	      able  libraries. For example, on cross-compiled cluster environ‐
	      ments, 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  commands  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_PRE‐
	      FIX_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 vari‐
	      able.  It defaults to "Unspecified".

       CMAKE_INSTALL_PREFIX
	      Install directory used by install.

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

	      On UNIX one can use the DESTDIR mechanism in order  to  relocate
	      the whole installation.  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" prepended 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 prepended with some other prefix.

	      The  installation	 prefix	 is  also  added  to CMAKE_SYSTEM_PRE‐
	      FIX_PATH	so  that  find_package,	 find_program,	 find_library,
	      find_path,  and find_file will search the prefix for other soft‐
	      ware.

       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  currently	 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 Vis‐
	      ual  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(VER‐
	      SION)  by default leave policies introduced after the given ver‐
	      sion unset.  Set CMAKE_POLICY_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_PRO‐
	      GRAM() will check each of	 the  contained	 directories  for  the
	      existence of the program which is currently 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 immediately,  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 incompatible but possibly link‐
	      able libraries. For example, on cross-compiled cluster  environ‐
	      ments,  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_SYSTEM_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 commands 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_SYS‐
	      TEM_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 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_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 and the
	      CMAKE_INSTALL_PREFIX.  It is NOT intended to be modified by  the
	      project,	use  CMAKE_PREFIX_PATH	for  this. See also CMAKE_SYS‐
	      TEM_INCLUDE_PATH,	 CMAKE_SYSTEM_LIBRARY_PATH,  CMAKE_SYSTEM_PRO‐
	      GRAM_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_PRO‐
	      GRAM() will check each of	 the  contained	 directories  for  the
	      existence of the program 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_PRO‐
	      GRAM_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() com‐
	      mands.  It is loaded after CMake's builtin compiler and platform
	      information  modules have been loaded but before the information
	      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 initial‐
	      ize 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_DIREC‐
	      TORY  that affect the placement of binaries.  Information set in
	      the file will be used for try_compile and try_run builds too.

       CMAKE_WARN_DEPRECATED
	      Whether to issue deprecation warnings for macros and functions.

	      If TRUE, this can be used by macros and functions to issue  dep‐
	      recation warnings.  This variable is FALSE by default.

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

	      This variable is	used  by  CMake-generated  cmake_install.cmake
	      scripts.	If  one	 sets  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 OS X.

	      Set to true on Mac OS X.

       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  Mi‐
	      crosoft.

       CMAKE_HOST_APPLE
	      True for Apple OS X operating systems.

	      Set to true when the host system is Apple OS X.

       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 system 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_SYS‐
	      TEM_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  tar‐
	      geting.	 On systems that have the uname command, this variable
	      is set to the output of uname -s.	 Linux, Windows,   and	Darwin
	      for  Mac	OS  X 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  out‐
	      put  of uname -p, on windows it is set to the value of the envi‐
	      ronment 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 variable 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.

       ENV    Access environment variables.

	      Use the syntax $ENV{VAR} to read environment variable VAR.   See
	      also the set() command to set ENV{VAR}.

       MSVC   True when using Microsoft Visual C

	      Set  to true when the compiler is some version of Microsoft Vis‐
	      ual C.

       MSVC10 True when using Microsoft Visual C 10.0

	      Set to true when the compiler is version 10.0 of Microsoft  Vis‐
	      ual C.

       MSVC11 True when using Microsoft Visual C 11.0

	      Set  to true when the compiler is version 11.0 of Microsoft Vis‐
	      ual C.

       MSVC12 True when using Microsoft Visual C 12.0

	      Set to true when the compiler is version 12.0 of Microsoft  Vis‐
	      ual 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
		1800 = VS 12.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 spec‐
	      ified in "Xcode.app/Contents/version.plist" (such as "3.1.2").

VARIABLES COMMON TO ALL CPACK GENERATORS
       CPACK_ABSOLUTE_DESTINATION_FILES
	      List  of files which have been installed using  an ABSOLUTE DES‐
	      TINATION path.

	      This variable is a Read-Only variable which is set internally by
	      CPack during installation and before packaging using CMAKE_ABSO‐
	      LUTE_DESTINATION_FILES defined in	 cmake_install.cmake  scripts.
	      The  value  can  be used within CPack project configuration file
	      and/or CPack<GEN>.cmake file of <GEN> generator.

       CPACK_BINARY_<GENNAME>
	      CPack generated options for binary generators

	      The CPack.cmake module generates (when  CPACK_GENERATOR  is  not
	      set) a set of CMake options (see CMake option command) which may
	      then be used to select the CPack generator(s) to	be  used  when
	      launching the package target.

       CPACK_CMAKE_GENERATOR
	      What  CMake  generator  should  be  used if the project is CMake
	      project.

	      Defaults to the value of CMAKE_GENERATOR few users will want  to
	      change this setting.

       CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY
	      Boolean toggle to include/exclude top level directory (component
	      case).

	      Similar usage as CPACK_INCLUDE_TOPLEVEL_DIRECTORY	 but  for  the
	      component	 case. See CPACK_INCLUDE_TOPLEVEL_DIRECTORY documenta‐
	      tion for the detail.

       CPACK_CREATE_DESKTOP_LINKS
	      List of desktop links to create

       CPACK_GENERATOR
	      List of CPack generators to use

	      If  not  specified,  CPack  will	create	a   set	  of   options
	      CPACK_BINARY_<GENNAME>  (e.g.,  CPACK_BINARY_NSIS)  allowing the
	      user to enable/disable individual generators. This variable  may
	      be used on the command line as well as in:

		  cpack -D CPACK_GENERATOR="ZIP;TGZ" /path/to/build/tree

       CPACK_INCLUDE_TOPLEVEL_DIRECTORY
	      Boolean toggle to include/exclude top level directory.

	      When  preparing  a  package  CPack  installs  the item under the
	      so-called top level directory. The purpose of is to include (set
	      to  1  or	 ON or TRUE) the top level directory in the package or
	      not (set to 0 or OFF or FALSE).

	      Each CPack generator has a built-in default value for this vari‐
	      able.  E.g.  Archive generators (ZIP, TGZ, ...) includes the top
	      level whereas RPM or  DEB	 don't.	 The  user  may	 override  the
	      default value by setting this variable.

	      There	 is	 a	similar	     variable	  CPACK_COMPO‐
	      NENT_INCLUDE_TOPLEVEL_DIRECTORY which may be  used  to  override
	      the  behavior  for  the  component packaging case which may have
	      different default value for historical (now backward compatibil‐
	      ity) reason.

       CPACK_INSTALLED_DIRECTORIES
	      Extra directories to install

       CPACK_INSTALL_CMAKE_PROJECTS
	      List of four values that specify what project to install.

	      The four values are: Build directory, Project Name, Project Com‐
	      ponent, Directory. If omitted, CPack  will  build	 an  installer
	      that installers everything.

       CPACK_INSTALL_COMMANDS
	      Extra commands to install components

       CPACK_INSTALL_SCRIPT
	      Extra CMake script provided by the user.

	      If  set  this  CMake script will be executed by CPack during its
	      local [CPack-private] installation which is  done	 right	before
	      packaging	 the  files.  The  script  is not called by e.g.: make
	      install.

       CPACK_MONOLITHIC_INSTALL
	      Disables the component-based installation mechanism.

	      When  set	 the  component	 specification	is  ignored  and   all
	      installed	 items	are put in a single "MONOLITHIC" package. Some
	      CPack generators do monolithic packaging by default and  may  be
	      asked  to do component packaging by setting CPACK_<GENNAME>_COM‐
	      PONENT_INSTALL to 1/TRUE.

       CPACK_OUTPUT_CONFIG_FILE
	      The name of the CPack binary configuration file.

	      This file is the CPack configuration generated by the CPack mod‐
	      ule for binary installers. Defaults to CPackConfig.cmake.

       CPACK_PACKAGE_DESCRIPTION_FILE
	      A text file used to describe the project.

	      Used,  for example, the introduction screen of a CPack-generated
	      Windows installer to describe the project.

       CPACK_PACKAGE_DESCRIPTION_SUMMARY
	      Short description of the project (only a few words).

       CPACK_PACKAGE_DIRECTORY
	      The directory in which CPack is doing its packaging.

	      If it is not set then this  will	default	 (internally)  to  the
	      build  dir. This variable may be defined in CPack config file or
	      from the cpack command line option "-B". If set the command line
	      option override the value found in the config file.

       CPACK_PACKAGE_EXECUTABLES
	      Lists  each  of  the executables and associated text label to be
	      used to create Start Menu shortcuts.

	      For example, setting this to the list ccmake;CMake will create a
	      shortcut	named  "CMake"	that  will  execute the installed exe‐
	      cutable ccmake. Not all CPack generators use it (at  least  NSIS
	      and OSXX11 do).

       CPACK_PACKAGE_FILE_NAME
	      The  name	 of  the  package  file to generate, not including the
	      extension.

	      For example, cmake-2.6.1-Linux-i686. The default value is

		${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-${CPACK_SYSTEM_NAME}.

       CPACK_PACKAGE_ICON
	      A branding image that will be  displayed	inside	the  installer
	      (used by GUI installers).

       CPACK_PACKAGE_INSTALL_DIRECTORY
	      Installation directory on the target system.

	      This may be used by some CPack generators like NSIS to create an
	      installation directory e.g., "CMake 2.5" below the  installation
	      prefix. All installed element will be put inside this directory.

       CPACK_PACKAGE_INSTALL_REGISTRY_KEY
	      Registry key used when installing this project.

	      This  is only used by installer for Windows.   The default value
	      is based on the installation directory.

       CPACK_PACKAGE_NAME
	      The name of the package (or application)

	      If not specified, defaults to the project name.

       CPACK_PACKAGE_VENDOR
	      The name of the package vendor

	      (e.g., "Kitware").

       CPACK_PACKAGE_VERSION
	      Package full version, used internally

	      By default,  this	 is  built  from  CPACK_PACKAGE_VERSION_MAJOR,
	      CPACK_PACKAGE_VERSION_MINOR, and CPACK_PACKAGE_VERSION_PATCH.

       CPACK_PACKAGE_VERSION_MAJOR
	      Package major Version

       CPACK_PACKAGE_VERSION_MINOR
	      Package minor Version

       CPACK_PACKAGE_VERSION_PATCH
	      Package patch Version

       CPACK_PACKAGING_INSTALL_PREFIX
	      The prefix used in the built package.

	      Each  CPack  generator  has  a  default  value (like /usr). This
	      default value may be overwritten from the CMakeLists.txt or  the
	      cpack command line by setting an alternative value.

	      e.g.  set(CPACK_PACKAGING_INSTALL_PREFIX "/opt")

	      This  is	not  the same purpose as CMAKE_INSTALL_PREFIX which is
	      used when installing from the  build  tree  without  building  a
	      package.

       CPACK_PROJECT_CONFIG_FILE
	      CPack-time project CPack configuration file.

	      This file included at cpack time, once per generator after CPack
	      has set CPACK_GENERATOR to the actual generator being  used.  It
	      allows per-generator setting of CPACK_* variables at cpack time.

       CPACK_RESOURCE_FILE_LICENSE
	      License to be embedded in the installer

	      It  will	typically be displayed to the user by the produced in‐
	      staller (often with an explicit "Accept" button,	for  graphical
	      installers)  prior  to  installation.  This  license file is NOT
	      added to installed file but is used  by  some  CPack  generators
	      like  NSIS.  If  you  want to install a license file (may be the
	      same as this one) along with your project you must add an appro‐
	      priate CMake INSTALL command in your CMakeLists.txt.

       CPACK_RESOURCE_FILE_README
	      ReadMe file to be embedded in the installer

	      It typically describes in some detail the purpose of the project
	      during the installation. Not  all	 CPack	generators  uses  this
	      file.

       CPACK_RESOURCE_FILE_WELCOME
	      Welcome file to be embedded in the installer.

	      It  welcomes  users  to  this  installer.	 Typically used in the
	      graphical installers on Windows and Mac OS X.

       CPACK_SET_DESTDIR
	      Boolean toggle to make CPack use DESTDIR mechanism when  packag‐
	      ing.

	      DESTDIR  means  DESTination  DIRectory.  It  is commonly used by
	      makefile users in order to install software at non-default loca‐
	      tion. It is a basic relocation mechanism that should not be used
	      on Windows (see CMAKE_INSTALL_PREFIX documentation). It is  usu‐
	      ally invoked like this:

	       make DESTDIR=/home/john install

	      which will install the concerned software using the installation
	      prefix, e.g. "/usr/local" prepended with the DESTDIR value which
	      finally  gives "/home/john/usr/local". When preparing a package,
	      CPack first installs the items to be packaged in a local (to the
	      build  tree) directory by using the same DESTDIR mechanism. Nev‐
	      ertheless, if CPACK_SET_DESTDIR is set then CPack will set DEST‐
	      DIR  before doing the local install. The most noticeable differ‐
	      ence is that without CPACK_SET_DESTDIR, CPack uses CPACK_PACKAG‐
	      ING_INSTALL_PREFIX  as  a	 prefix whereas with CPACK_SET_DESTDIR
	      set, CPack will use CMAKE_INSTALL_PREFIX as a prefix.

	      Manually setting CPACK_SET_DESTDIR may help (or simply be neces‐
	      sary) if some install rules uses absolute DESTINATION (see CMake
	      INSTALL command). However, starting with CPack/CMake  2.8.3  RPM
	      and DEB installers tries to handle DESTDIR automatically so that
	      it is seldom necessary for the user to set it.

       CPACK_SOURCE_GENERATOR
	      List of generators used for the source packages.

	      As with CPACK_GENERATOR, if this is  not	specified  then	 CPack
	      will  create  a set of options (e.g., CPACK_SOURCE_ZIP) allowing
	      users to select which packages will be generated.

       CPACK_SOURCE_IGNORE_FILES
	      Pattern of files in the source tree that won't be packaged  when
	      building a source package.

	      This  is	a  list	 of  regular expression patterns (that must be
	      properly			   escaped),			 e.g.,
	      /CVS/;/\\.svn/;\\.swp$;\\.#;/#;.*~;cscope.*

       CPACK_SOURCE_OUTPUT_CONFIG_FILE
	      The name of the CPack source configuration file.

	      This file is the CPack configuration generated by the CPack mod‐
	      ule for source installers. Defaults to CPackSourceConfig.cmake.

       CPACK_SOURCE_PACKAGE_FILE_NAME
	      The name of the source package

	      For example cmake-2.6.1.

       CPACK_SOURCE_STRIP_FILES
	      List of files in the source tree that will be stripped.

	      Starting with CMake 2.6.0	 CPACK_SOURCE_STRIP_FILES  will	 be  a
	      boolean variable which enables stripping of all files (a list of
	      files evaluates to TRUE in CMake, so this change is compatible).

       CPACK_STRIP_FILES
	      List of files to be stripped

	      Starting with CMake 2.6.0 CPACK_STRIP_FILES will	be  a  boolean
	      variable	which  enables stripping of all files (a list of files
	      evaluates to TRUE in CMake, so this change is compatible).

       CPACK_SYSTEM_NAME
	      System name, defaults to the value of ${CMAKE_SYSTEM_NAME}.

       CPACK_TOPLEVEL_TAG
	      Directory for the installed files

       CPACK_WARN_ON_ABSOLUTE_INSTALL_DESTINATION
	      Ask CPack to warn each time a file with absolute INSTALL	DESTI‐
	      NATION is encountered.

	      This  variable  triggers	the  definition of CMAKE_WARN_ON_ABSO‐
	      LUTE_INSTALL_DESTINATION	when  CPack  runs  cmake_install.cmake
	      scripts.

VARIABLES CONCERNING CPACK COMPONENTS
       CPACK_<GENNAME>_COMPONENT_INSTALL
	      Enable/Disable component install for CPack generator <GENNAME>.

	      Each  CPack Generator (RPM, DEB, ARCHIVE, NSIS, DMG, etc...) has
	      a legacy default behavior. e.g. RPM  builds  monolithic  whereas
	      NSIS  builds  component.	One can change the default behavior by
	      setting this variable to 0/1 or OFF/ON.

       CPACK_COMPONENTS_ALL
	      The list of component to install

	      The default value of this variable is computed by CPack and con‐
	      tains all components defined by the project. The user may set it
	      to only include the specified components.

       CPACK_COMPONENTS_GROUPING
	      Specify how components  are  grouped  for	 multi-package	compo‐
	      nent-aware CPack generators.

	      Some  generators like RPM or ARCHIVE family (TGZ, ZIP, ...) gen‐
	      erates several packages files when asked for  component  packag‐
	      ing. They group the component differently depending on the value
	      of this variable:

		- ONE_PER_GROUP (default): creates one package file per component group
		- ALL_COMPONENTS_IN_ONE : creates a single package with all (requested) component
		- IGNORE : creates one package per component, i.e. IGNORE component group

	      One can specify different grouping for different CPack generator
	      by using a CPACK_PROJECT_CONFIG_FILE.

       CPACK_COMPONENT_<compName>_DEPENDS
	      The  dependencies	 (list	of components) on which this component
	      depends.

       CPACK_COMPONENT_<compName>_DESCRIPTION
	      The description of a component

       CPACK_COMPONENT_<compName>_DISPLAY_NAME
	      The name to be displayed for a component

       CPACK_COMPONENT_<compName>_GROUP
	      The group of a component

       CPACK_COMPONENT_<compName>_REQUIRED
	      True is this component is required

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>_CRE‐
	      ATE_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>_CRE‐
	      ATE_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>_CRE‐
	      ATE_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_lan‐
	      guage() 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 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
	      Flags for all build types.

	      <LANG> flags used regardless of the value of CMAKE_BUILD_TYPE.

       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 language 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 target_link_libraries() CMake will generate the -l<name> form
	      on  link lines to ensure the linker searches its implicit direc‐
	      tories 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 language.	  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-spe‐
	      cific   system   library	 search	  directory   such   as	 <pre‐
	      fix>/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  property sets the language explic‐
	      itly.  Otherwise, the linker language is that whose linker pref‐
	      erence value is highest among languages compiled and linked into
	      the target.  See also the	 CMAKE_<LANG>_LINKER_PREFERENCE_PROPA‐
	      GATES variable.

       CMAKE_<LANG>_LINKER_PREFERENCE_PROPAGATES
	      True  if	CMAKE_<LANG>_LINKER_PREFERENCE	propagates across tar‐
	      gets.

	      This is used when CMake selects a linker language for a  target.
	      Languages	 compiled  directly into the target are always consid‐
	      ered.  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 an executable.

	      Rule variable to link an 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 language's 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 vari‐
	      ables, this  uses	 the  GNU  syntax  for	identifying  languages
	      instead  of  the	CMake  syntax. Recognized values of the <LANG>
	      suffix 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  For‐
	      tran_MODULE_DIRECTORY target 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 lan‐
	      guage <LANG>.

VARIABLES SPECIFIC TO CPACK BUNDLE GENERATOR
       CPACK_BUNDLE_ICON
	      Path to an OSX icon file that will be used as the icon  for  the
	      generated bundle.

	      This  is the icon that appears in the OSX finder for the bundle,
	      and in the OSX dock when the bundle is opened. Required.

       CPACK_BUNDLE_NAME
	      The name of the generated bundle

	      This appears in the OSX finder as the bundle name. Required.

       CPACK_BUNDLE_PLIST
	      Path to an OSX plist file that will be used  for	the  generated
	      bundle.

	      This  assumes  that  the caller has generated or specified their
	      own Info.plist file. Required.

       CPACK_BUNDLE_STARTUP_COMMAND
	      Path to a startup script

	      This is a path to an executable or script that will be run when‐
	      ever  an	end-user double-clicks the generated bundle in the OSX
	      Finder. Optional.

VARIABLES SPECIFIC TO CPACK CYGWIN GENERATOR
       CPACK_CYGWIN_BUILD_SCRIPT
	      The Cygwin build script

		 FIXME: This documentation is incomplete.

       CPACK_CYGWIN_PATCH_FILE
	      The Cygwin patch file

		 FIXME: This documentation is incomplete.

       CPACK_CYGWIN_PATCH_NUMBER
	      The Cygwin patch number

		 FIXME: This documentation is incomplete.

VARIABLES SPECIFIC TO CPACK DEBIAN (DEB) GENERATOR
       CPACK_DEBIAN_PACKAGE_ARCHITECTURE
		   Mandatory : YES
		   Default   : Output of dpkg --print-architecture (or i386 if dpkg is not found)
		   The debian package architecture

       CPACK_DEBIAN_PACKAGE_BREAKS
		   Mandatory : NO
		   Default   : -
		   see http://www.debian.org/doc/debian-policy/ch-relationships.html#s-binarydeps
		   When one binary package declares that it breaks another, dpkg will refuse to allow the
		   package which declares Breaks be installed unless the broken package is deconfigured first,
		   and it will refuse to allow the broken package to be reconfigured.

       CPACK_DEBIAN_PACKAGE_CONFLICTS
		   Mandatory : NO
		   Default   : -
		   see http://www.debian.org/doc/debian-policy/ch-relationships.html#s-binarydeps
		   When one binary package declares a conflict with another using a Conflicts field,
		   dpkg will refuse to allow them to be installed on the system at the same time.

       CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA
		   Mandatory : NO
		   Default   : -
		   This variable allow advanced user to add custom script to the control.tar.gz
		   Typical usage is for conffiles, postinst, postrm, prerm.
		   Usage: set(CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA
			  "${CMAKE_CURRENT_SOURCE_DIR/prerm;${CMAKE_CURRENT_SOURCE_DIR}/postrm")

       CPACK_DEBIAN_PACKAGE_DEBUG
		   Mandatory : NO
		   Default   : -
		   May be set when invoking cpack in order to trace debug information
		   during CPackDeb run.

       CPACK_DEBIAN_PACKAGE_DEPENDS
		   Mandatory : NO
		   Default   : -
		   May be used to set deb dependencies.

       CPACK_DEBIAN_PACKAGE_DESCRIPTION
		   Mandatory : YES
		   Default   : CPACK_PACKAGE_DESCRIPTION_SUMMARY
		   The debian package description

       CPACK_DEBIAN_PACKAGE_ENHANCES
		   Mandatory : NO
		   Default   : -
		   see http://www.debian.org/doc/debian-policy/ch-relationships.html#s-binarydeps
		   This field is similar to Suggests but works in the opposite direction.
		   It is used to declare that a package can enhance the functionality of another package.

       CPACK_DEBIAN_PACKAGE_HOMEPAGE
		   Mandatory : NO
		   Default   : -
		   The URL of the web site for this package, preferably (when applicable) the
		   site from which the original source can be obtained and any additional
		   upstream documentation or information may be found.
		   The content of this field is a simple URL without any surrounding
		   characters such as <>.

       CPACK_DEBIAN_PACKAGE_MAINTAINER
		   Mandatory : YES
		   Default   : CPACK_PACKAGE_CONTACT
		   The debian package maintainer

       CPACK_DEBIAN_PACKAGE_NAME
		   Mandatory : YES
		   Default   : CPACK_PACKAGE_NAME (lower case)
		   The debian package summary

       CPACK_DEBIAN_PACKAGE_PREDEPENDS
		   Mandatory : NO
		   Default   : -
		   see http://www.debian.org/doc/debian-policy/ch-relationships.html#s-binarydeps
		   This field is like Depends, except that it also forces dpkg to complete installation of
		   the packages named before even starting the installation of the package which declares
		   the pre-dependency.

       CPACK_DEBIAN_PACKAGE_PRIORITY
		   Mandatory : YES
		   Default   : 'optional'
		   The debian package priority

       CPACK_DEBIAN_PACKAGE_PROVIDES
		   Mandatory : NO
		   Default   : -
		   see http://www.debian.org/doc/debian-policy/ch-relationships.html#s-binarydeps
		   A virtual package is one which appears in the Provides control field of another package.

       CPACK_DEBIAN_PACKAGE_RECOMMENDS
		   Mandatory : NO
		   Default   : -
		   see http://www.debian.org/doc/debian-policy/ch-relationships.html#s-binarydeps
		   Allows packages to declare a strong, but not absolute, dependency on other packages.

       CPACK_DEBIAN_PACKAGE_REPLACES
		   Mandatory : NO
		   Default   : -
		   see http://www.debian.org/doc/debian-policy/ch-relationships.html#s-binarydeps
		   Packages can declare in their control file that they should overwrite
		   files in certain other packages, or completely replace other packages.

       CPACK_DEBIAN_PACKAGE_SECTION
		   Mandatory : YES
		   Default   : 'devel'
		   The debian package section

       CPACK_DEBIAN_PACKAGE_SHLIBDEPS
		   Mandatory : NO
		   Default   : OFF
		   May be set to ON in order to use dpkg-shlibdeps to generate
		   better package dependency list.
		   You may need set CMAKE_INSTALL_RPATH toi appropriate value
		   if you use this feature, because if you don't dpkg-shlibdeps
		   may fail to find your own shared libs.
		   See http://www.cmake.org/Wiki/CMake_RPATH_handling.

       CPACK_DEBIAN_PACKAGE_SUGGESTS
		   Mandatory : NO
		   Default   : -
		   see http://www.debian.org/doc/debian-policy/ch-relationships.html#s-binarydeps
		   Allows packages to declare a suggested package install grouping.

       CPACK_DEBIAN_PACKAGE_VERSION
		   Mandatory : YES
		   Default   : CPACK_PACKAGE_VERSION
		   The debian package version

VARIABLES SPECIFIC TO CPACK DRAGNDROP GENERATOR
       CPACK_COMMAND_HDIUTIL
	      Path to the hdiutil(1) command used to  operate  on  disk	 image
	      files on Mac OS X.

	      This variable can be used to override the automatically detected
	      command (or specify its location if the auto-detection fails  to
	      find it.)

       CPACK_COMMAND_REZ
	      Path  to	the Rez(1) command used to compile resources on Mac OS
	      X.

	      This variable can be used to override the automatically detected
	      command  (or specify its location if the auto-detection fails to
	      find it.)

       CPACK_COMMAND_SETFILE
	      Path to the SetFile(1) command used to set  extended  attributes
	      on files and directories on Mac OS X.

	      This variable can be used to override the automatically detected
	      command (or specify its location if the auto-detection fails  to
	      find it.)

       CPACK_DMG_BACKGROUND_IMAGE
	      Path to a background image file

	      This  file  will be used as the background for the Finder Window
	      when the disk image is opened.  By default no  background	 image
	      is  set. The background image is applied after applying the cus‐
	      tom .DS_Store file.

       CPACK_DMG_DS_STORE
	      Path to a custom DS_Store file

	      This .DS_Store file e.g. can be used to specify the Finder  win‐
	      dow  position/geometry  and  layout  (such  as  hidden toolbars,
	      placement of the icons etc.). This file has to be	 generated  by
	      the  Finder (either manually or through OSA-script) using a nor‐
	      mal folder from which the .DS_Store file can then be extracted.

       CPACK_DMG_FORMAT
	      The disk image format

	      Common values are UDRO (UDIF read-only),	UDZO  (UDIF  zlib-com‐
	      pressed)	or  UDBZ  (UDIF bzip2-compressed). Refer to hdiutil(1)
	      for more information on other available formats.

       CPACK_DMG_VOLUME_NAME
	      The volume name of the generated disk image.

	      Defaults to CPACK_PACKAGE_FILE_NAME.

VARIABLES SPECIFIC TO CPACK NSIS GENERATOR
       CPACK_NSIS_COMPRESSOR
	      The arguments that will be passed to the NSIS SetCompressor com‐
	      mand.

       CPACK_NSIS_CONTACT
	      Contact information for questions and comments about the instal‐
	      lation process.

       CPACK_NSIS_CREATE_ICONS_EXTRA
	      Additional NSIS commands for creating start menu shortcuts.

       CPACK_NSIS_DELETE_ICONS_EXTRA
	      Additional NSIS commands to uninstall start menu shortcuts.

       CPACK_NSIS_DISPLAY_NAME
	      The display name string that appears in	the Windows Add/Remove
	      Program control panel

       CPACK_NSIS_ENABLE_UNINSTALL_BEFORE_INSTALL
	      Ask about uninstalling previous versions first.

		 If this is set to "ON", then an installer will look for previous
		 installed versions and if one is found, ask the user whether to
		 uninstall it before proceeding with the install.

       CPACK_NSIS_EXECUTABLES_DIRECTORY
	      Creating	NSIS  start  menu links assumes that they are in 'bin'
	      unless this variable is set.

		 For example, you would set this to 'exec' if your executables are
		 in an exec directory.

       CPACK_NSIS_EXTRA_INSTALL_COMMANDS
	      Extra NSIS commands that	 will be  added	 to  the  end  of  the
	      install Section, after your

	       install tree is available on the target system.

       CPACK_NSIS_EXTRA_PREINSTALL_COMMANDS
	      Extra NSIS commands that	 will be added to the beginning of the
	      install Section, before your

	       install tree is available on the target system.

       CPACK_NSIS_EXTRA_UNINSTALL_COMMANDS
	      Extra NSIS commands that will   be added to the  uninstall  Sec‐
	      tion, before your install tree is

	       removed from the target system.

       CPACK_NSIS_HELP_LINK
	      URL to a web site providing assistance in installing your appli‐
	      cation.

       CPACK_NSIS_INSTALLED_ICON_NAME
	      A path to the executable that contains the installer icon.

       CPACK_NSIS_INSTALLER_MUI_ICON_CODE
	      undocumented

       CPACK_NSIS_INSTALL_ROOT
	      The default installation directory presented to the end user  by
	      the NSIS installer is under this root dir.

	      The full	 directory presented to the end user is:

		 ${CPACK_NSIS_INSTALL_ROOT}/${CPACK_PACKAGE_INSTALL_DIRECTORY}

       CPACK_NSIS_MENU_LINKS
	      Specify links in [application] menu

		 This should contain a list of pair "link" "link name". The link
		 may be an URL or a path relative to installation prefix.
		 Like:
		   set(CPACK_NSIS_MENU_LINKS
		       "doc/cmake-@CMake_VERSION_MAJOR@.@CMake_VERSION_MINOR@/cmake.html" "CMake Help"
		       "http://www.cmake.org" "CMake Web Site")

       CPACK_NSIS_MODIFY_PATH
	      Modify PATH toggle

		 If this is set to "ON", then an extra page
		 will appear in the installer that will allow the user to choose
		 whether the program directory should be added to the system PATH
		 variable.

       CPACK_NSIS_MUI_FINISHPAGE_RUN
	      Specify an executable to add an option to run on the finish page
	      of the NSIS installer.

       CPACK_NSIS_MUI_ICON
	      An icon filename

		 The name of a *.ico file used as the main icon for the generated
		 install program.

       CPACK_NSIS_MUI_UNIICON
	      An icon filename

		 The name of a *.ico file used as the main icon for the generated
		 uninstall program.

       CPACK_NSIS_PACKAGE_NAME
	      The title displayed at the top of the installer.

       CPACK_NSIS_URL_INFO_ABOUT
	      URL to a web site providing more information about your applica‐
	      tion.

VARIABLES SPECIFIC TO CPACK PACKAGEMAKER GENERATOR
       CPACK_OSX_PACKAGE_VERSION
	      The  version of Mac OS X that the resulting PackageMaker archive
	      should be compatible with.

	      Different versions of Mac OS X support different	features.  For
	      example, CPack can only build component-based installers for Mac
	      OS X 10.4 or newer, and can only build installers that  download
	      component son-the-fly for Mac OS X 10.5 or newer. If left blank,
	      this value will be set to the minimum version of Mac OS  X  that
	      supports the requested features. Set this variable to some value
	      (e.g., 10.4) only if you want to guarantee that  your  installer
	      will  work  on  that version of Mac OS X, and don't mind missing
	      extra features available in the installer	 shipping  with	 later
	      versions of Mac OS X.

VARIABLES SPECIFIC TO CPACK RPM GENERATOR
       CPACK_RPM_CHANGELOG_FILE
	      RPM changelog file

		   Mandatory : NO
		   Default   : -
		   May be used to embed a changelog in the spec file.
		   The refered file will be read and directly put after the %changelog
		   section.

       CPACK_RPM_COMPRESSION_TYPE
	      RPM compression type

		   Mandatory : NO
		   Default   : -
		   May be used to override RPM compression type to be used
		   to build the RPM. For example some Linux distribution now default
		   to lzma or xz compression whereas older cannot use such RPM.
		   Using this one can enforce compression type to be used.
		   Possible value are: lzma, xz, bzip2 and gzip.

       CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST
	      list of path to be excluded

		   Mandatory : NO
		   Default   : /etc /etc/init.d /usr /usr/share /usr/share/doc /usr/bin /usr/lib /usr/lib64 /usr/include
		   May be used to exclude path (directories or files) from the auto-generated
		   list of paths discovered by CPack RPM. The defaut value contains a reasonable
		   set of values if the variable is not defined by the user. If the variable
		   is defined by the user then CPackRPM will NOT any of the default path.
		   If you want to add some path to the default list then you can use
		   CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION variable.

       CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION
	      additional list of path to be excluded

		   Mandatory : NO
		   Default   : -
		   May be used to add more exclude path (directories or files) from the initial
		   default list of excluded paths. See CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST.

       CPACK_RPM_GENERATE_USER_BINARY_SPECFILE_TEMPLATE
	      Spec file template

		   Mandatory : NO
		   Default   : -
		   If set CPack will generate a template for USER specified binary
		   spec file and stop with an error. For example launch CPack like this
		   cpack -D CPACK_RPM_GENERATE_USER_BINARY_SPECFILE_TEMPLATE=1 -G RPM
		   The user may then use this file in order to hand-craft is own
		   binary spec file which may be used with CPACK_RPM_USER_BINARY_SPECFILE.

       CPACK_RPM_PACKAGE_ARCHITECTURE
	      The RPM package architecture

		   Mandatory : NO
		   Default   : -
		   This may be set to "noarch" if you
		   know you are building a noarch package.

       CPACK_RPM_PACKAGE_DEBUG
	      Toggle CPackRPM debug output

		   Mandatory : NO
		   Default   : -
		   May be set when invoking cpack in order to trace debug information
		   during CPack RPM run. For example you may launch CPack like this
		   cpack -D CPACK_RPM_PACKAGE_DEBUG=1 -G RPM

       CPACK_RPM_PACKAGE_DESCRIPTION
	      RPM package description

		   Mandatory : YES
		   Default   : CPACK_PACKAGE_DESCRIPTION_FILE if set or "no package description available"

       CPACK_RPM_PACKAGE_GROUP
	      The RPM package group

		   Mandatory : YES
		   Default   : "unknown"

       CPACK_RPM_PACKAGE_LICENSE
	      The RPM package license policy

		   Mandatory : YES
		   Default   : "unknown"

       CPACK_RPM_PACKAGE_NAME
	      The RPM package name

		   Mandatory : YES
		   Default   : CPACK_PACKAGE_NAME

       CPACK_RPM_PACKAGE_OBSOLETES
	      RPM spec obsoletes field

		   Mandatory : NO
		   Default   : -
		   May be used to set RPM packages that are obsoleted by this one.

       CPACK_RPM_PACKAGE_PROVIDES
	      RPM spec provides field

		   Mandatory : NO
		   Default   : -
		   May be used to set RPM dependencies (provides).
		   The provided package list of an RPM file could be printed with
		   rpm -qp --provides file.rpm

       CPACK_RPM_PACKAGE_RELEASE
	      The RPM package release

		   Mandatory : YES
		   Default   : 1
		   This is the numbering of the RPM package
		   itself, i.e. the version of the packaging and not the version of the
		   content (see CPACK_RPM_PACKAGE_VERSION). One may change the default
		   value if the previous packaging was buggy and/or you want to put here
		   a fancy Linux distro specific numbering.

       CPACK_RPM_PACKAGE_RELOCATABLE
	      build a relocatable RPM

		   Mandatory : NO
		   Default   : CPACK_PACKAGE_RELOCATABLE
		   If this variable is set to TRUE or ON CPackRPM will try
		   to build a relocatable RPM package. A relocatable RPM may
		   be installed using rpm --prefix or --relocate in order to
		   install it at an alternate place see rpm(8).
		   Note that currently this may fail if CPACK_SET_DESTDIR is set to ON.
		   If CPACK_SET_DESTDIR is set then you will get a warning message
		   but if there is file installed with absolute path you'll get
		   unexpected behavior.

       CPACK_RPM_PACKAGE_REQUIRES
	      RPM spec requires field

		   Mandatory : NO
		   Default   : -
		   May be used to set RPM dependencies (requires).
		   Note that you must enclose the complete requires string between quotes,
		   for example:
		   set(CPACK_RPM_PACKAGE_REQUIRES "python >= 2.5.0, cmake >= 2.8")
		   The required package list of an RPM file could be printed with
		   rpm -qp --requires file.rpm

       CPACK_RPM_PACKAGE_SUGGESTS
	      RPM spec suggest field

		   Mandatory : NO
		   Default   : -
		   May be used to set weak RPM dependencies (suggests).
		   Note that you must enclose the complete requires string between quotes.

       CPACK_RPM_PACKAGE_SUMMARY
	      The RPM package summary

		   Mandatory : YES
		   Default   : CPACK_PACKAGE_DESCRIPTION_SUMMARY

       CPACK_RPM_PACKAGE_URL
	      The projects URL

		   Mandatory : NO
		   Default   : -

       CPACK_RPM_PACKAGE_VENDOR
	      The RPM package vendor

		   Mandatory : YES
		   Default   : CPACK_PACKAGE_VENDOR if set or "unknown"

       CPACK_RPM_PACKAGE_VERSION
	      The RPM package version

		   Mandatory : YES
		   Default   : CPACK_PACKAGE_VERSION

       CPACK_RPM_POST_INSTALL_SCRIPT_FILE
		CPACK_RPM_POST_UNINSTALL_SCRIPT_FILE
		   Mandatory : NO
		   Default   : -
		   May be used to embed a post (un)installation script in the spec file.
		   The refered script file(s) will be read and directly
		   put after the %post or %postun section
		   If CPACK_RPM_COMPONENT_INSTALL is set to ON the (un)install script for
		   each component can be overridden with
		   CPACK_RPM_<COMPONENT>_POST_INSTALL_SCRIPT_FILE and
		   CPACK_RPM_<COMPONENT>_POST_UNINSTALL_SCRIPT_FILE
		   One may verify which scriptlet has been included with
		    rpm -qp --scripts  package.rpm

       CPACK_RPM_PRE_INSTALL_SCRIPT_FILE
		CPACK_RPM_PRE_UNINSTALL_SCRIPT_FILE
		   Mandatory : NO
		   Default   : -
		   May be used to embed a pre (un)installation script in the spec file.
		   The refered script file(s) will be read and directly
		   put after the %pre or %preun section
		   If CPACK_RPM_COMPONENT_INSTALL is set to ON the (un)install script for
		   each component can be overridden with
		   CPACK_RPM_<COMPONENT>_PRE_INSTALL_SCRIPT_FILE and
		   CPACK_RPM_<COMPONENT>_PRE_UNINSTALL_SCRIPT_FILE
		   One may verify which scriptlet has been included with
		    rpm -qp --scripts  package.rpm

       CPACK_RPM_SPEC_INSTALL_POST
	      [deprecated]

		   Mandatory : NO
		   Default   : -
		   This way of specifying post-install script is deprecated use
		   CPACK_RPM_POST_INSTALL_SCRIPT_FILE
		   May be used to set an RPM post-install command inside the spec file.
		   For example setting it to "/bin/true" may be used to prevent
		   rpmbuild to strip binaries.

       CPACK_RPM_SPEC_MORE_DEFINE
	      RPM extended spec definitions lines

		   Mandatory : NO
		   Default   : -
		   May be used to add any %define lines to the generated spec file.

       CPACK_RPM_USER_BINARY_SPECFILE
	      A user provided spec file

		   Mandatory : NO
		   Default   : -
		   May be set by the user in order to specify a USER binary spec file
		   to be used by CPackRPM instead of generating the file.
		   The specified file will be processed by configure_file( @ONLY).
		   One can provide a component specific file by setting
		   CPACK_RPM_<componentName>_USER_BINARY_SPECFILE.

       CPACK_RPM_USER_FILELIST
		CPACK_RPM_<COMPONENT>_USER_FILELIST
		   Mandatory : NO
		   Default   : -
		   May be used to explicitly specify %(<directive>) file line
		   in the spec file. Like %config(noreplace) or any other directive
		   that be found in the %files section. Since CPackRPM is generating
		   the list of files (and directories) the user specified files of
		   the CPACK_RPM_<COMPONENT>_USER_FILELIST list will be removed from the generated list.

VARIABLES SPECIFIC TO CPACK WIX GENERATOR
       CPACK_WIX_CULTURES
	      Language(s) of the installer

	      Languages	 are compiled into the WixUI extension library. To use
	      them, simply provide the name of the culture.   If  you  specify
	      more  than one culture identifier in a comma or semicolon delim‐
	      ited list, the first one that is found will be  used.   You  can
	      find  a  list  of	 supported  languages  at:  http://wix.source‐
	      forge.net/manual-wix3/WixUI_localization.htm

       CPACK_WIX_LICENSE_RTF
	      RTF License File

	      If CPACK_RESOURCE_FILE_LICENSE has an .rtf extension it is  used
	      as-is.

	      If  CPACK_RESOURCE_FILE_LICENSE  has  an	.txt  extension	 it is
	      implicitly converted to RTF by the WiX Generator.

	      With CPACK_WIX_LICENSE_RTF you can  override  the	 license  file
	      used by the WiX Generator in case CPACK_RESOURCE_FILE_LICENSE is
	      in an unsupported format or the .txt -> .rtf conversion does not
	      work as expected.

       CPACK_WIX_PRODUCT_GUID
	      Product GUID (Product/@Id)

	      Will be automatically generated unless explicitly provided.

	      If  explicitly provided this will set the Product Id of your in‐
	      staller.

	      The installer will abort if it detects a pre-existing  installa‐
	      tion that uses the same GUID.

	      The    GUID    shall    use    the    syntax    described	   for
	      CPACK_WIX_UPGRADE_GUID.

       CPACK_WIX_PRODUCT_ICON
	      The Icon shown next to the program name in Add/Remove programs

	      If set, this icon is used in place of the default icon.

       CPACK_WIX_PROGRAM_MENU_FOLDER
	      Start menu folder name for launcher

	      If this variable	is  not	 set,  it  will	 be  initialized  with
	      CPACK_PACKAGE_NAME

       CPACK_WIX_TEMPLATE
	      Template file for WiX generation

	      If  this variable is set, the specified template will be used to
	      generate the WiX wxs file. This should be used if	 further  cus‐
	      tomization of the output is required.

	      If  this	variable is not set, the default MSI template included
	      with CMake will be used.

       CPACK_WIX_UI_BANNER
	      The bitmap will appear at the top of all installer  pages	 other
	      than the welcome and completion dialogs

	      If set, this image will replace the default banner image.

	      This image must be 493 by 58 pixels.

       CPACK_WIX_UI_DIALOG
	      Background bitmap used on the welcome and completion dialogs

	      If  this variable is set, the installer will replace the default
	      dialog image.

	      This image must be 493 by 312 pixels.

       CPACK_WIX_UPGRADE_GUID
	      Upgrade GUID (Product/@UpgradeCode)

	      Will be automatically generated unless explicitly provided.

	      It should be explicitly set to a	constant  generated  gloabally
	      unique  identifier  (GUID)  to  allow your installers to replace
	      existing installations that use the same GUID.

	      You may for example explicitly set this variable in your	CMake‐
	      Lists.txt	 to the value that has been generated per default. You
	      should not use GUIDs that you did not generate yourself or which
	      may belong to other projects.

	      A	  GUID	 shall	 have	the  following	fixed  length  syntax:
	      XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX

		(each X represents an uppercase hexadecimal digit)

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

	      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_<LANG>_VISIBILITY_PRESET
	      Default value for <LANG>_VISIBILITY_PRESET of targets.

	      This variable is used to initialize the <LANG>_VISIBILITY_PRESET
	      property on all the targets.  See that target property for addi‐
	      tional information.

       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 addi‐
	      tional 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  informa‐
	      tion.

       CMAKE_AUTOMOC_MOC_OPTIONS
	      Additional  options  for moc when using automoc (see CMAKE_AUTO‐
	      MOC).

	      This variable is	used  to  initialize  the  AUTOMOC_MOC_OPTIONS
	      property on all the targets.  See that target property for addi‐
	      tional 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_<CON‐
	      FIG>_POSTFIX variable for the DEBUG configuration.

       CMAKE_EXE_LINKER_FLAGS
	      Linker flags to be used to create executables.

	      These flags will be used by the linker  when  creating  an  exe‐
	      cutable.

       CMAKE_EXE_LINKER_FLAGS_<CONFIG>
	      Flags to be 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 addi‐
	      tional information.

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

	      This variable is used to initialize the GNUtoMS property on tar‐
	      gets  when they are created.  See that target property for addi‐
	      tional 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_CUR‐
	      RENT_BINARY_DIR}	to  the include path for this directory. These
	      additional include directories do not propagate down  to	subdi‐
	      rectories. 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 INTERFACE_INCLUDE_DIRECTORIES.

	      If this variable is enabled, CMake automatically adds  for  each
	      shared  library target, static library target, module target and
	      executable target, ${CMAKE_CURRENT_SOURCE_DIR} and  ${CMAKE_CUR‐
	      RENT_BINARY_DIR} to the INTERFACE_INCLUDE_DIRECTORIES.By default
	      CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE is OFF.

       CMAKE_INSTALL_NAME_DIR
	      Mac OS X directory name for installed targets.

	      CMAKE_INSTALL_NAME_DIR	is    used    to    initialize	   the
	      INSTALL_NAME_DIR	property on all targets. See that target prop‐
	      erty 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 out‐
	      side the project to the INSTALL_RPATH.  This is used to initial‐
	      ize the target property INSTALL_RPATH_USE_LINK_PATH for all tar‐
	      gets.

       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 addi‐
	      tional information.

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

	      The flag will be used to specify a library directory to the com‐
	      piler.  On most compilers this is "-L".

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

	      The  flag will be 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 addi‐
	      tional information.

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

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

       CMAKE_LINK_LIBRARY_FLAG
	      Flag to be used to link a library into an executable.

	      The flag will be used to specify a library to link  to  an  exe‐
	      cutable.	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_MODULE_LINKER_FLAGS
	      Linker flags to be used to create modules.

	      These flags will be used by the linker when creating a module.

       CMAKE_MODULE_LINKER_FLAGS_<CONFIG>
	      Flags to be used when linking a module.

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

       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 instal‐
	      lation than it does in the build tree, CMake uses a builtin edi‐
	      tor to change the RPATH in the installed copy.  If this variable
	      is  set to true then CMake will relink the binary before instal‐
	      lation instead of using its builtin editor.

       CMAKE_PDB_OUTPUT_DIRECTORY
	      Where to put all the MS debug symbol files from linker.

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

       CMAKE_POSITION_INDEPENDENT_CODE
	      Default value for POSITION_INDEPENDENT_CODE of targets.

	      This  variable  is  used	to  initialize	the  POSITION_INDEPEN‐
	      DENT_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 addi‐
	      tional information.

       CMAKE_SHARED_LINKER_FLAGS
	      Linker flags to be used to create shared libraries.

	      These flags will be used by the linker when  creating  a	shared
	      library.

       CMAKE_SHARED_LINKER_FLAGS_<CONFIG>
	      Flags to be used when linking a shared library.

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

       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 installa‐
	      tion  step.   To omit RPATH in both the build and install steps,
	      use CMAKE_SKIP_RPATH instead.

       CMAKE_STATIC_LINKER_FLAGS
	      Linker flags to be used to create static libraries.

	      These flags will be used by the linker when  creating  a	static
	      library.

       CMAKE_STATIC_LINKER_FLAGS_<CONFIG>
	      Flags to be used when linking a static library.

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

       CMAKE_TRY_COMPILE_CONFIGURATION
	      Build configuration used for try_compile and try_run projects.

	      Projects	built  by  try_compile	and  try_run  are  built  syn‐
	      chronously  during  the  CMake  configuration step.  Therefore a
	      specific build configuration must be chosen even if  the	gener‐
	      ated build system supports multiple configurations.

       CMAKE_USE_RELATIVE_PATHS
	      Use relative paths (May not work!).

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

       CMAKE_VISIBILITY_INLINES_HIDDEN
	      Default value for VISIBILITY_INLINES_HIDDEN of targets.

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

       CMAKE_WIN32_EXECUTABLE
	      Default value for WIN32_EXECUTABLE of targets.

	      This variable is used to initialize the  WIN32_EXECUTABLE	 prop‐
	      erty  on	all  the  targets.  See that target property for addi‐
	      tional 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 oth‐
	      erwise placed in this directory.

       LIBRARY_OUTPUT_PATH
	      Old library location variable.

	      The  target  properties  ARCHIVE_OUTPUT_DIRECTORY,  LIBRARY_OUT‐
	      PUT_DIRECTORY, and RUNTIME_OUTPUT_DIRECTORY supercede this vari‐
	      able for a target if they are set.  Library targets  are	other‐
	      wise placed in this directory.

VARIABLES THAT PROVIDE INFORMATION
       CMAKE_AR
	      Name of archiving tool for static libraries.

	      This  specifies  the 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 num‐
	      ber 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 number 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 Stu‐
	      dio 6, the CMAKE_BUILD_TOOL will be set to msdev, for Unix Make‐
	      files  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	CMake‐
	      Cache.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  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  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  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  generators
	      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  suitable  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  pur‐
	      pose but has been left for compatibility with existing projects.
	      Instead add_custom_command() recognizes 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-configuration build systems the value of this  variable
	      is  passed as the value of preprocessor 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.  Specifically 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_subdirec‐
	      tory 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_CURRENT_LIST_FILE) is  located.
	      The  value has dynamic scope.  When CMake starts processing com‐
	      mands in a source file it sets this variable  to	the  directory
	      where this file is located.  When CMake finishes processing com‐
	      mands 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 vari‐
	      able inside a macro or function is the file  invoking  the  bot‐
	      tom-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,  usu‐
	      ally -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 graphi‐
	      cally 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 filename 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 Makefiles (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 recog‐
	      nize 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 filename 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 filename, .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_MINIMUM_REQUIRED_VERSION
	      Version specified to cmake_minimum_required command

	      Variable containing  the	VERSION	 component  specified  in  the
	      cmake_minimum_required command.

       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 CMake file that included the current one.

	      While processing a CMake file loaded by include() or  find_pack‐
	      age() this variable contains the full path to the file including
	      it.  The top of the include stack is always  the	CMakeLists.txt
	      for the current directory.  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 command.

       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 for‐
	      mat: ${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 filename, .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 filename 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  executables.  The default is to add rpath informa‐
	      tion 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  executa‐
	      bles 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 filename, .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 com‐
	      mand line as it is used.

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

	      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 ver‐
	      sion  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  use‐
	      ful when SUBDIR is used to connect several 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  use‐
	      ful when add_subdirectory is used to connect several projects.

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

       Redistribution and use in source and binary forms, with or without mod‐
       ification,  are	permitted  provided  that the following conditions are
       met:

       Redistributions of source code must retain the above copyright  notice,
       this list of conditions 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 provided 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 per‐
       mission.

       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 PARTIC‐
       ULAR  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 SUBSTITUTE 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
       cmake(1), ccmake(1)

       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	 ques‐
	      tions.

       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 posting	 ques‐
	      tions to the list.

AUTHOR
       This manual page was generated by the "--help-man" option.

cpack 2.8.12.2			 May 13, 2014			      cpack(1)
[top]

List of man pages available for Alpinelinux

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net