|
|
| Line 1: |
Line 1: |
| <pre>
| | See https://cmake.org/cmake/help/v2.8.9/cpack.html |
| cpack version 2.8.9
| |
| ------------------------------------------------------------------------------
| |
| 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 generator 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 thenCPack.cmake
| |
| defines it from CPACK_PACKAGE_VERSION_[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 directoryCPack
| |
| 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 suffix. 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 displayed.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 displayed.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 format 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
| |
| | |
| 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
| |
| component, which the user can opt to install or remove as part of
| |
| the graphical installation process. compname is the name of the
| |
| component, 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 therefore
| |
| will always be installed. It will be visible in the graphical
| |
| installer, but it cannot be unselected. (Typically, required
| |
| components are shown greyed out).
| |
| | |
|
| |
| | |
| DISABLED indicates that this component should be disabled
| |
| (unselected) 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
| |
| inconsitent sets of components.
| |
| | |
|
| |
| | |
| GROUP names the component group of which this component is a
| |
| part. If not provided, the component will be a standalone
| |
| component, 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 component
| |
| is a part. When one of these installations types is selected, this
| |
| component will automatically be selected. Installation types are
| |
| described with the cpack_add_install_type command, 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_configure_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_PACKAGE_FILE_NAME and
| |
| the name of the component. See cpack_configure_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
| |
| information 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,
| |
| providing 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
| |
| components 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 component
| |
| selections to the graphical installer.
| |
| | |
| cpack_add_install_type(typename
| |
| [DISPLAY_NAME name])
| |
| | |
|
| |
| | |
| The cpack_add_install_type command identifies a set of preselected
| |
| 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 application'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
| |
| installer. 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 installation-time
| |
| downloads of selected components. For each downloadable component,
| |
| CPack will create an archive containing the contents 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 download 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 functionality
| |
| 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. Otherwise, only
| |
| those components explicitly marked as DOWNLOADED or that have a specified
| |
| ARCHIVE_FILE will be downloaded. Additionally, the ALL option implies
| |
| ADD_REMOVE (unless NO_ADD_REMOVE is specified).
| |
| | |
|
| |
| | |
| ADD_REMOVE indicates that CPack should install a copy of the installer
| |
| 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_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 specified.
| |
| 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 specified 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 subdirectory to
| |
| protect its parents and siblings. CMake also manages a new entry for
| |
| scripts loaded by include() and find_package() commands except when
| |
| invoked with the NO_POLICY_SCOPE option (see also policy CMP0011).
| |
| The cmake_policy command provides 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 created 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 directory. 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.
| |
| | |
| 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 specified, only variables of the form @VAR@
| |
| will be replaces and ${VAR} will be ignored. This is useful for
| |
| configuring scripts that use ${VAR}. Any occurrences of #cmakedefine
| |
| VAR will be replaced with either #define VAR or /* #undef VAR */
| |
| depending on the setting of VAR in CMake. Any occurrences of
| |
| #cmakedefine01 VAR will be replaced with either #define VAR 1 or
| |
| #define VAR 0 depending on whether VAR evaluates to TRUE or FALSE in
| |
| CMake.
| |
| | |
| 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 standard
| |
| 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 TIMEOUT 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 standard 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 compatibility.
| |
| | |
| 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_MD5 sum])
| |
| file(UPLOAD filename url [INACTIVITY_TIMEOUT timeout]
| |
| [TIMEOUT timeout] [STATUS status] [LOG log] [SHOW_PROGRESS])
| |
| | |
| 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.
| |
| | |
| 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 variable.
| |
| 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 RELATIVE flag is
| |
| specified for an expression, the results will be returned as a
| |
| relative path to the given path. (We do not recommend 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 windows 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 specified, 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 operation should terminate. If
| |
| EXPECTED_MD5 sum is specified, the operation will verify that the
| |
| downloaded file's actual md5 sum matches the expected value. If it
| |
| does not match, the operation fails with an error. If SHOW_PROGRESS
| |
| is specified, progress information will be printed as status messages
| |
| until the operation is complete.
| |
| | |
| 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 specified 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 complete.
| |
| | |
| 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 destination 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_PERMISSIONS). See the install(DIRECTORY)
| |
| command for documentation of permissions, PATTERN, REGEX, and EXCLUDE
| |
| options.
| |
| | |
| The INSTALL signature differs slightly from COPY: it prints status
| |
| messages, and NO_SOURCE_PERMISSIONS is default. Installation scripts
| |
| generated by the install() command use this signature (with some
| |
| undocumented options for internal use).
| |
| | |
| 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 sufficient 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 command. 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 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 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 for each <prefix> in CMAKE_PREFIX_PATH
| |
| CMAKE_INCLUDE_PATH
| |
| CMAKE_FRAMEWORK_PATH
| |
| | |
| 2. Search paths specified in cmake-specific environment variables.
| |
| These are intended to be set in the user's shell configuration. This
| |
| can be skipped if NO_CMAKE_ENVIRONMENT_PATH is passed.
| |
| | |
| <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 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 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 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 variable
| |
| 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 locations. 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
| |
| directories 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 sufficient in
| |
| many cases. It is the same as find_library(<VAR> name1 [PATHS path1
| |
| path2 ...])
| |
| | |
| find_library(
| |
| <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 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 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>/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 variables.
| |
| These are intended to be set in the user's shell configuration. 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 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 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 variable
| |
| 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 locations. 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
| |
| directories 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.
| |
| | |
| 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 command 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. <package>_FOUND
| |
| will be set to indicate whether the package was found. When the
| |
| package is found package-specific information is provided through
| |
| variables 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
| |
| processing 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 component list is given to a recursive invocation
| |
| inside a find-module, 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-package 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 responsible for finding the package, checking the
| |
| version, and producing 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 command
| |
| 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 configuration file names may be given
| |
| using the CONFIGS option. The search procedure is specified below.
| |
| Once found, the configuration 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 <package>_CONSIDERED_CONFIGS,
| |
| the associated versions in <package>_CONSIDERED_VERSIONS.
| |
| | |
| If the package configuration file cannot be found CMake will generate
| |
| an error describing the problem unless the QUIET argument 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 version file is located next
| |
| to it and named either "<config-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 version 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 procedure.
| |
| 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 without
| |
| 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 corresponds
| |
| 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 specified 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 convention, so all (W) and (U) directories
| |
| are still searched on all platforms. Directories marked with (A) are
| |
| intended for installations 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 following
| |
| 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 variables.
| |
| These are intended to be set in the user's shell configuration. 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 dependent 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 Windows 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 typically
| |
| hard-coded guesses.
| |
| | |
| On Darwin or systems supporting OS X Frameworks, the cmake variable
| |
| 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 locations. 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
| |
| directories 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 setting the
| |
| variable CMAKE_DISABLE_FIND_PACKAGE_<package> to TRUE. See the
| |
| documentation for the CMAKE_DISABLE_FIND_PACKAGE_<package> 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 returning):
| |
| | |
| <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 sufficient 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 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 for each <prefix> in CMAKE_PREFIX_PATH
| |
| CMAKE_INCLUDE_PATH
| |
| CMAKE_FRAMEWORK_PATH
| |
| | |
| 2. Search paths specified in cmake-specific environment variables.
| |
| These are intended to be set in the user's shell configuration. This
| |
| can be skipped if NO_CMAKE_ENVIRONMENT_PATH is passed.
| |
| | |
| <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 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 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 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 variable
| |
| 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 locations. 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
| |
| directories 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/Headers/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 sufficient 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 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>/[s]bin for each <prefix> in CMAKE_PREFIX_PATH
| |
| CMAKE_PROGRAM_PATH
| |
| CMAKE_APPBUNDLE_PATH
| |
| | |
| 2. Search paths specified in cmake-specific environment variables.
| |
| These are intended to be set in the user's shell configuration. 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 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 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 variable
| |
| 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 locations. 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
| |
| directories 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 evaluated, 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 function 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 reference the variable 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 functions with
| |
| optional arguments. Additionally ARGV holds the list of all arguments
| |
| given to the function and ARGN holds the list of argument past the
| |
| last expected argument.
| |
| | |
| 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 property 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 COMPONENTS.
| |
| | |
| 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
| |
| PATH|ABSOLUTE|NAME|EXT|NAME_WE|REALPATH
| |
| [CACHE])
| |
| | |
| Set <VAR> to be the path (PATH), file name (NAME), file extension
| |
| (EXT), file name without extension (NAME_WE) of FileName, the full
| |
| path (ABSOLUTE), or the full path with all symlinks resolved
| |
| (REALPATH). Note that the path is converted to Unix slashes format
| |
| and has no trailing slashes. 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 PROGRAM, 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 documentation 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 commands
| |
| 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 followed 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 number.
| |
| False if the constant is 0, OFF, NO, FALSE, N, IGNORE, "", 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 variables.)
| |
| | |
| 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(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 lexicographically 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, predating
| |
| 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 STRGREATER
| |
| 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 VERSION_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
| |
| Read CMake listfile code from the given file.
| |
| | |
| include(<file|module> [OPTIONAL] [RESULT_VARIABLE <VAR>]
| |
| [NO_POLICY_SCOPE])
| |
| | |
| Reads CMake listfile code from the given file. Commands in the file
| |
| are processed immediately as if they were written in place of the
| |
| include command. 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 location.
| |
| | |
| 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 representing 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 matching endmacro,
| |
| are not invoked until the macro is invoked. When it is invoked, the
| |
| commands recorded in the macro 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 reference the values ${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.
| |
| Additionally ${ARGV} holds the list of all arguments given to the
| |
| macro and ${ARGN} holds the list of argument past the last expected
| |
| argument. Note that the parameters to a macro and values 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 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 variable
| |
| 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 neither 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 return 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 but skip generation
| |
| FATAL_ERROR = CMake Error, stop all processing
| |
| | |
| 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_package()), 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 CMakeLists.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 function 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 whitespace. 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 double-quoted.
| |
| Backslashes are literal unless they precede double-quotes. See the
| |
| MSDN article "Parsing C Command-Line Arguments" 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 <variable> 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 variable
| |
| 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 variable 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 languages); they are
| |
| not persisted across CMake runs. Cache variables (unless set with
| |
| INTERNAL) are mostly intended for configuration 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 compiler 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 parent project. The parent project can achieve this
| |
| simply by setting 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 properties
| |
| 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 existing 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])
| |
| | |
| 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-delimited
| |
| 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 characters.
| |
| | |
| 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 characters
| |
| 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 expressions:
| |
| | |
| ^ Matches at beginning of a line
| |
| $ Matches at end of a line
| |
| . Matches any single character
| |
| [ ] Matches any character(s) inside the brackets
| |
| [^ ] Matches any character(s) not inside the brackets
| |
| - Matches any character in range on either side of a dash
| |
| * 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).
| |
| | |
| 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 following 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 condition 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 previous
| |
| CMake versions, which are still supported for compatibility reasons. You
| |
| should instead use the newer, faster and shinier new commands. ;-)
| |
| | |
| ------------------------------------------------------------------------------
| |
| Standard CMake 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 referenced
| |
| unambiguously.
| |
| | |
| Makefile generators are capable of supporting duplicate custom target
| |
| names. For projects that care only about Makefile generators 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 produce an error and
| |
| refuse to generate the project.
| |
| | |
| 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 target_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 directories.
| |
| | |
| FIND_LIBRARY_USE_LIB64_PATHS is a boolean specifying whether the
| |
| FIND_LIBRARY command should automatically search the lib64 variant 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 versioned 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 configuration.
| |
| | |
| 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 documentation 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 launchers 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 completes.
| |
| 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 property. 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 property 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 considered
| |
| 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 convenience 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. Setting 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 variables
| |
| 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-separated
| |
| 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_<CONFIG> where <CONFIG> is an upper-case
| |
| name (ex. "COMPILE_DEFINITIONS_DEBUG"). This property will be
| |
| initialized in each directory by its value in the directory's parent.
| |
| | |
| CMake will automatically drop some definitions that are not supported
| |
| 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 escaping
| |
| 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 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_DEFINITIONS.
| |
| This property will be initialized in each directory by its value in
| |
| the directory's parent.
| |
| | |
| | |
| 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 directory.
| |
| | |
| 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 literal). 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 directory.
| |
| 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 directories 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 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_directories
| |
| 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_OPTIMIZATION.
| |
| 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 currently
| |
| 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.
| |
| | |
| ------------------------------------------------------------------------------
| |
| 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-separated
| |
| 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_<CONFIG> where <CONFIG> is an upper-case
| |
| name (ex. "COMPILE_DEFINITIONS_DEBUG").
| |
| | |
| CMake will automatically drop some definitions that are not supported
| |
| 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 escaping
| |
| 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 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_DEFINITIONS.
| |
| 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 corresponding format
| |
| flag to the compiler. Consider using the target-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. Otherwise 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 is certain dependency information should be computed.
| |
| | |
| 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. Setting this
| |
| property for a file means this file will be compiled. Do not set this
| |
| for header or files that should not be compiled.
| |
| | |
| 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 frameworks the content folder is
| |
| "<name>.framework/Versions/<version>". For cfbundles the content
| |
| folder is "<name>.bundle/Contents" (unless the extension is changed).
| |
| See the PUBLIC_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 purpose, 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 recompiled. 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 then 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.
| |
| | |
| 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
| |
| corresponding 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_ARCHIVE_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_ARCHIVE_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: 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
| |
| 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_OUTPUT_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() macro. Currently Qt4 is 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.
| |
| Additionally, 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>_automoc.cpp file, which is
| |
| compiled as part of the target.This property 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
| |
| AUTOMOC_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.
| |
| | |
| 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 relinking
| |
| 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.
| |
| | |
| COMPILE_DEFINITIONS
| |
| Preprocessor definitions for compiling a target's sources.
| |
| | |
| The COMPILE_DEFINITIONS property may be set to a semicolon-separated
| |
| 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_<CONFIG> where <CONFIG> is an upper-case
| |
| name (ex. "COMPILE_DEFINITIONS_DEBUG").
| |
| | |
| CMake will automatically drop some definitions that are not supported
| |
| 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 escaping
| |
| 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 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_DEFINITIONS.
| |
| | |
| 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.
| |
| | |
| DEBUG_POSTFIX
| |
| See target property <CONFIG>_POSTFIX.
| |
| | |
| This property is a special case of the more-general <CONFIG>_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 our outside to
| |
| properly setup dllexport/dllimport decorations.
| |
| | |
| ENABLE_EXPORTS
| |
| Specify whether an executable exports symbols for loadable modules.
| |
| | |
| 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 executable with the
| |
| TARGET_LINK_LIBRARIES command. On all platforms 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 linking. All Windows-based systems
| |
| including Cygwin are DLL platforms. 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 Makefile for
| |
| example typing make will cause this target to be built. The same
| |
| concept applies to the default build of other generators. Installing
| |
| a target with EXCLUDE_FROM_ALL set to true has undefined behavior.
| |
| | |
| 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 entities 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 suitable 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-specific 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 specifies 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
| |
| project or dsp file associated with this target.
| |
| | |
| 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 literal). 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> property. 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 including 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 IMPORTED_LINK_INTERFACE_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 completely
| |
| overrides the generic property for the named configuration.
| |
| | |
| 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 completely
| |
| overrides the generic property for the named configuration.
| |
| | |
| 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.
| |
| | |
| 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 completely
| |
| overrides the generic property for the named configuration.
| |
| | |
| 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_MULTIPLICITY.
| |
| | |
| 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-specific
| |
| property IMPORTED_LOCATION_<CONFIG> is set. To get the location of an
| |
| imported target read one of the LOCATION or LOCATION_<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 "soname".
| |
| | |
| 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 directories 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 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_directories
| |
| command.
| |
| | |
| 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 property 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.
| |
| | |
| 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_OPTIMIZATION.
| |
| 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
| |
| corresponding 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 target 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: 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
| |
| 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_OUTPUT_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_PREFERENCE variables.
| |
| | |
| 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_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 configuration
| |
| <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 executable.
| |
| | |
| 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.
| |
| | |
| LINK_INTERFACE_LIBRARIES_<CONFIG>
| |
| Per-configuration list of public interface libraries for a target.
| |
| | |
| This is the configuration-specific version of
| |
| LINK_INTERFACE_LIBRARIES. If set, this property completely overrides
| |
| the generic property for the named configuration.
| |
| | |
| 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_INTERFACE_MULTIPLICITY. If set, this property completely
| |
| overrides the generic property for the named configuration.
| |
| | |
| 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 configuration
| |
| <CONFIG> provided by the target.
| |
| | |
| For a non-imported target, this property is provided for compatibility
| |
| with CMake 2.4 and below. It was meant to get the location of an
| |
| executable target's output file for use in add_custom_command. The
| |
| path may contain a build-system-specific portion that is replaced at
| |
| build time with the configuration getting 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 recognizes generator
| |
| expressions to refer to target locations anywhere 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)(_<CONFIG>)?" or
| |
| "(IMPLIB_)?(PREFIX|SUFFIX)". 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 configuration. 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)(_<CONFIG>)?" or
| |
| "(IMPLIB_)?(PREFIX|SUFFIX)". 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 bundle. 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 MacOSXBundleInfo.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 targets 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.
| |
| | |
| An library target with FRAMEWORK enabled will be built as a framework
| |
| on Mac OS X. By default its Info.plist file is created by configuring
| |
| a template called MacOSXFrameworkInfo.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 targets 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.
| |
| | |
| MAP_IMPORTED_CONFIG_<CONFIG>
| |
| Map from project configuration to IMPORTED target's configuration.
| |
| | |
| Set this to the list of configurations of an imported target that may
| |
| be used for the current project's <CONFIG> configuration. 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 configurations are suitable for use
| |
| when building the <CONFIG> configuration. 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.
| |
| | |
| 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 supports 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. Therefore, 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 architecture 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 executable 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.
| |
| | |
| POSITION_INDEPENDENT_CODE
| |
| Whether to create a position-independent target
| |
| | |
| The POSITION_INDEPENDENT_CODE property determines whether position
| |
| independent executables or shared libraries will be created. This
| |
| property is true by default for SHARED and MODULE library targets and
| |
| false otherwise.
| |
| | |
| 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 target.
| |
| | |
| Shared library targets marked with the FRAMEWORK property generate
| |
| 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 framework folder. On non-Apple
| |
| platforms these headers may be installed using the PRIVATE_HEADER
| |
| option to the install(TARGETS) 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 Visual
| |
| Studio.
| |
| | |
| PUBLIC_HEADER
| |
| Specify public header files in a FRAMEWORK shared library target.
| |
| | |
| Shared library targets marked with the FRAMEWORK property generate
| |
| 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 generate
| |
| 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
| |
| corresponding 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_RUNTIME_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_RUNTIME_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: 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
| |
| 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_OUTPUT_NAME.
| |
| | |
| SKIP_BUILD_RPATH
| |
| Should rpaths be used for the build tree.
| |
| | |
| SKIP_BUILD_RPATH is a boolean specifying whether to skip automatic
| |
| 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_properties command.
| |
| | |
| SOVERSION
| |
| What version number is this target.
| |
| | |
| For shared libraries VERSION and SOVERSION can be used to specify the
| |
| build version and api version respectively. When building or
| |
| installing appropriate symlinks are created if the platform 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 executable.
| |
| | |
| 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 specify the
| |
| build version and api version respectively. When building or
| |
| installing appropriate symlinks are created if the platform 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 symlinks 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.
| |
| | |
| VS_DOTNET_REFERENCES
| |
| Visual Studio managed project .NET references
| |
| | |
| Adds one or more semicolon-delimited .NET references to a generated
| |
| Visual Studio project. For example, "System;System.Windows.Forms".
| |
| | |
| 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 better 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 managed 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 testing
| |
| project:
| |
| | |
| {3AC096D0-A1C2-E12C-1390-A8335801FDAB};{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}
| |
| | |
| UUIDs are semicolon-delimited.
| |
| | |
| 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 auxpath
| |
| 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 generated
| |
| Visual Studio project. For example, "Windows;Windows.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 of
| |
| just main().This makes it a GUI executable instead of a console
| |
| 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_EXECUTABLE 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 generators.
| |
| | |
| ------------------------------------------------------------------------------
| |
| 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 expressions,
| |
| the test will fail.For example: PASS_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 conjunction 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 guaranteed
| |
| 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 PARALLEL_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 executable
| |
| 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 definition
| |
| 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 DESTINATION
| |
| path.
| |
| | |
| This variable is defined by CMake-generated cmake_install.cmake
| |
| scripts. It can be used (read-only) by program or script that source
| |
| those install scripts. This is used by some CPack generators (e.g.
| |
| RPM).
| |
| | |
| CMAKE_AUTOMOC_RELAXED_MODE
| |
| Switch between strict and relaxed automoc mode.
| |
| | |
| By default, automoc behaves exactly as described in the documentation
| |
| of the 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 specifies what
| |
| version of CMake should be supported. By default this value is the
| |
| version number of CMake that you are running. You can set this to an
| |
| older version of CMake to support 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 for make based generators.
| |
| | |
| This specifies what build type will be built in this tree. Possible
| |
| values are empty, Debug, Release, RelWithDebInfo and MinSizeRel. This
| |
| variable is only supported for make based generators. If this
| |
| variable is supported, then CMake will also provide initial values for
| |
| the variables with the name
| |
| CMAKE_C_FLAGS_[DEBUG|RELEASE|RELWITHDEBINFO|MINSIZEREL]. For example,
| |
| if CMAKE_BUILD_TYPE is Debug, then CMAKE_C_FLAGS_DEBUG will be added
| |
| to the CMAKE_C_FLAGS.
| |
| | |
| CMAKE_COLOR_MAKEFILE
| |
| Enables color output when using the Makefile generator.
| |
| | |
| When enabled, the generated Makefiles will produce colored output.
| |
| Default is ON.
| |
| | |
| CMAKE_CONFIGURATION_TYPES
| |
| Specifies the available build types.
| |
| | |
| This specifies what build types will be available such as Debug,
| |
| Release, RelWithDebInfo etc. This has reasonable defaults on most
| |
| platforms. But can be extended to provide other build types. See
| |
| also CMAKE_BUILD_TYPE.
| |
| | |
| CMAKE_DISABLE_FIND_PACKAGE_<PackageName>
| |
| Variable for disabling find_package() calls.
| |
| | |
| Every non-REQUIRED find_package() call in a project can be disabled by
| |
| setting the variable CMAKE_DISABLE_FIND_PACKAGE_<PackageName> to TRUE.
| |
| This can be used to build a project without an optional package,
| |
| although that package is installed.
| |
| | |
| This switch should be used during the initial CMake run. Otherwise if
| |
| the package has already been found in a previous CMake run, the
| |
| variables which have been stored in the cache will still be there. In
| |
| the case it is recommended to remove the cache variables for this
| |
| package from the cache using the cache editor or cmake -U
| |
| | |
| CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION
| |
| Ask cmake_install.cmake script to error out as soon as a file with
| |
| absolute INSTALL DESTINATION is encountered.
| |
| | |
| The fatal error is emitted before the installation of the offending
| |
| file takes place. This variable is used by CMake-generated
| |
| cmake_install.cmake scripts. If ones set this variable to ON while
| |
| running the script, it may get fatal error 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 (MODULE,
| |
| 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 package
| |
| configuration file is found then the wording of the failure message
| |
| must account for both the case that the package is really missing and
| |
| the case that the project has a bug and failed to provide the intended
| |
| Find module. If instead the caller specifies an explicit mode option
| |
| then the failure message can be more specific.
| |
| | |
| Set CMAKE_FIND_PACKAGE_WARN_NO_MODULE to TRUE to tell find_package to
| |
| warn when it implicitly assumes Config mode. This helps developers
| |
| enforce use of an explicit mode in all calls to find_package within a
| |
| project.
| |
| | |
| CMAKE_IGNORE_PATH
| |
| Path to be ignored by FIND_XXX() commands.
| |
| | |
| Specifies directories to be ignored by searches in FIND_XXX() commands
| |
| This is useful in cross-compiled environments where some system
| |
| directories contain incompatible but possibly linkable libraries. For
| |
| example, on cross-compiled cluster environments, this allows a user to
| |
| ignore directories containing libraries meant for the front-end
| |
| machine that modules like FindX11 (and others) would normally search.
| |
| By default this is empty; it is intended to be set by the project.
| |
| Note that CMAKE_IGNORE_PATH takes a list of directory names, NOT a
| |
| list of prefixes. If you want to ignore paths under prefixes (bin,
| |
| include, lib, etc.), you'll need to specify them explicitly. See also
| |
| CMAKE_PREFIX_PATH, CMAKE_LIBRARY_PATH, CMAKE_INCLUDE_PATH,
| |
| CMAKE_PROGRAM_PATH.
| |
| | |
| CMAKE_INCLUDE_PATH
| |
| Path used for searching by FIND_FILE() and FIND_PATH().
| |
| | |
| Specifies a path which will be used both by FIND_FILE() and
| |
| FIND_PATH(). Both 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_PREFIX_PATH.
| |
| | |
| CMAKE_INSTALL_DEFAULT_COMPONENT_NAME
| |
| Default component used in install() commands.
| |
| | |
| If an install() command is used without the COMPONENT argument, these
| |
| files will be grouped into a default component. The name of this
| |
| default install component will be taken from this variable. It
| |
| defaults to "Unspecified".
| |
| | |
| CMAKE_INSTALL_PREFIX
| |
| Install directory used by install.
| |
| | |
| If "make install" is invoked or INSTALL is built, this directory is
| |
| pre-pended onto all install directories. This variable defaults to
| |
| /usr/local on UNIX and c:/Program Files on Windows.
| |
| | |
| 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 static the static MFC library,
| |
| and 2 for the shared MFC library. This is used in visual studio 6 and
| |
| 7 project files. The CMakeSetup dialog used MFC and the
| |
| CMakeLists.txt looks like this:
| |
| | |
| add_definitions(-D_AFXDLL)
| |
| | |
| set(CMAKE_MFC_FLAG 2)
| |
| | |
| add_executable(CMakeSetup WIN32 ${SRCS})
| |
| | |
| | |
| CMAKE_MODULE_PATH
| |
| List of directories to search for CMake modules.
| |
| | |
| Commands like include() and find_package() search for files in
| |
| directories listed by this variable before checking the default
| |
| modules that come with CMake.
| |
| | |
| CMAKE_NOT_USING_CONFIG_FLAGS
| |
| Skip _BUILD_TYPE flags if true.
| |
| | |
| This is an internal flag used by the generators in CMake to tell CMake
| |
| to skip the _BUILD_TYPE flags.
| |
| | |
| CMAKE_POLICY_DEFAULT_CMP<NNNN>
| |
| Default for CMake Policy CMP<NNNN> when it is otherwise left unset.
| |
| | |
| Commands cmake_minimum_required(VERSION) and cmake_policy(VERSION) by
| |
| default leave policies introduced after the given version unset. Set
| |
| CMAKE_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_POLICY_DEFAULT_CMP<NNNN>=<OLD|NEW>) to set
| |
| a policy not otherwise set by the project. Set to OLD to quiet a
| |
| policy warning while using old behavior or to NEW to try building the
| |
| project with new behavior.
| |
| | |
| CMAKE_PREFIX_PATH
| |
| Path used for searching by FIND_XXX(), with appropriate suffixes
| |
| added.
| |
| | |
| Specifies a path which will be used by the FIND_XXX() commands. It
| |
| contains the "base" directories, the FIND_XXX() commands append
| |
| appropriate subdirectories to the base directories. So FIND_PROGRAM()
| |
| adds /bin to each of the directories in the path, FIND_LIBRARY()
| |
| appends /lib to each of the directories, and FIND_PATH() and
| |
| FIND_FILE() append /include . By default it is empty, it is intended
| |
| to be set by the project. See also CMAKE_SYSTEM_PREFIX_PATH,
| |
| CMAKE_INCLUDE_PATH, CMAKE_LIBRARY_PATH, CMAKE_PROGRAM_PATH.
| |
| | |
| CMAKE_PROGRAM_PATH
| |
| Path used for searching by FIND_PROGRAM().
| |
| | |
| Specifies a path which will be used by FIND_PROGRAM(). FIND_PROGRAM()
| |
| will check each of the contained directories for the existence of the
| |
| program which is 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 linkable libraries. For
| |
| example, on cross-compiled cluster environments, this allows a user to
| |
| ignore directories containing libraries meant for the front-end
| |
| machine that modules like FindX11 (and others) would normally search.
| |
| By default this contains a list of directories containing incompatible
| |
| binaries for the host system. See also CMAKE_SYSTEM_PREFIX_PATH,
| |
| CMAKE_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_SYSTEM_PREFIX_PATH.
| |
| | |
| CMAKE_SYSTEM_LIBRARY_PATH
| |
| Path used for searching by FIND_LIBRARY().
| |
| | |
| Specifies a path which will be used by FIND_LIBRARY(). FIND_LIBRARY()
| |
| will check each of the contained directories for the existence of the
| |
| library which is 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. It is NOT intended to be modified
| |
| by the project, use CMAKE_PREFIX_PATH for this. See also
| |
| CMAKE_SYSTEM_INCLUDE_PATH, CMAKE_SYSTEM_LIBRARY_PATH,
| |
| CMAKE_SYSTEM_PROGRAM_PATH, and CMAKE_SYSTEM_IGNORE_PATH.
| |
| | |
| CMAKE_SYSTEM_PROGRAM_PATH
| |
| Path used for searching by FIND_PROGRAM().
| |
| | |
| Specifies a path which will be used by FIND_PROGRAM(). FIND_PROGRAM()
| |
| will check each of the contained directories for the existence of the
| |
| program which is 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_PROGRAM_PATH for this. See also
| |
| CMAKE_SYSTEM_PREFIX_PATH.
| |
| | |
| CMAKE_USER_MAKE_RULES_OVERRIDE
| |
| Specify a CMake file that overrides platform information.
| |
| | |
| CMake loads the specified file while enabling support for each
| |
| language from either the project() or enable_language() commands. It
| |
| is loaded after CMake's builtin compiler and platform information
| |
| modules have been loaded but before the 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 initialize CMAKE_C_FLAGS before it is cached.
| |
| The override file should NOT be used to set anything that could be set
| |
| after languages are enabled, such as variables like
| |
| CMAKE_RUNTIME_OUTPUT_DIRECTORY that affect the placement of binaries.
| |
| Information set in the file will be used for try_compile and try_run
| |
| builds too.
| |
| | |
| CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION
| |
| Ask cmake_install.cmake script to warn each time a file with absolute
| |
| INSTALL DESTINATION is encountered.
| |
| | |
| This variable is used by CMake-generated cmake_install.cmake scripts.
| |
| If ones set this variable to ON while running the script, it may get
| |
| warning messages from the script.
| |
| | |
| ------------------------------------------------------------------------------
| |
| Variables That Describe the System
| |
| | |
| APPLE
| |
| True if running on Mac OSX.
| |
| | |
| Set to true on Mac OSX.
| |
| | |
| BORLAND
| |
| True if the borland compiler is being used.
| |
| | |
| This is set to true if the Borland compiler is being used.
| |
| | |
| CMAKE_CL_64
| |
| Using the 64 bit compiler from Microsoft
| |
| | |
| Set to true when using the 64 bit cl compiler from Microsoft.
| |
| | |
| CMAKE_COMPILER_2005
| |
| Using the Visual Studio 2005 compiler from Microsoft
| |
| | |
| Set to true when using the Visual Studio 2005 compiler from Microsoft.
| |
| | |
| CMAKE_HOST_APPLE
| |
| True for Apple OSXoperating systems.
| |
| | |
| Set to true when the host system is Apple OSX.
| |
| | |
| CMAKE_HOST_SYSTEM
| |
| Name of system cmake is being run on.
| |
| | |
| The same as CMAKE_SYSTEM but for the host system instead of the target
| |
| system when cross compiling.
| |
| | |
| CMAKE_HOST_SYSTEM_NAME
| |
| Name of the OS CMake is running on.
| |
| | |
| The same as CMAKE_SYSTEM_NAME but for the host system instead of the
| |
| target system when cross compiling.
| |
| | |
| CMAKE_HOST_SYSTEM_PROCESSOR
| |
| The name of the CPU CMake is running on.
| |
| | |
| The same as CMAKE_SYSTEM_PROCESSOR but for the host system instead of
| |
| the target system when cross compiling.
| |
| | |
| CMAKE_HOST_SYSTEM_VERSION
| |
| OS version CMake is running on.
| |
| | |
| The same as CMAKE_SYSTEM_VERSION but for the host system instead of
| |
| the target 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_SYSTEM_NAME}-${CMAKE_SYSTEM_VERSION}. If CMAKE_SYSTEM_VERSION
| |
| is not set, then CMAKE_SYSTEM is the same as CMAKE_SYSTEM_NAME.
| |
| | |
| CMAKE_SYSTEM_NAME
| |
| Name of the OS CMake is building for.
| |
| | |
| This is the name of the operating system on which CMake is targeting.
| |
| On systems that have the uname command, this variable is set to the
| |
| output of uname -s. Linux, Windows, and Darwin for Mac OSX are the
| |
| values found on the big three operating systems.
| |
| | |
| CMAKE_SYSTEM_PROCESSOR
| |
| The name of the CPU CMake is building for.
| |
| | |
| On systems that support uname, this variable is set to the output of
| |
| uname -p, on windows it is set to the value of the environment
| |
| variable PROCESSOR_ARCHITECTURE
| |
| | |
| CMAKE_SYSTEM_VERSION
| |
| OS version CMake is building for.
| |
| | |
| A numeric version string for the system, on systems that support
| |
| uname, this 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.
| |
| | |
| MSVC
| |
| True when using Microsoft Visual C
| |
| | |
| Set to true when the compiler is some version 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.
| |
| | |
| 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
| |
| | |
| | |
| UNIX
| |
| True for UNIX and UNIX like operating systems.
| |
| | |
| Set to true when the target system is UNIX or UNIX like (i.e. APPLE
| |
| and CYGWIN).
| |
| | |
| WIN32
| |
| True on windows systems, including win64.
| |
| | |
| Set to true when the target system is Windows.
| |
| | |
| XCODE_VERSION
| |
| Version of Xcode (Xcode generator only).
| |
| | |
| Under the Xcode generator, this is the version of Xcode as specified
| |
| in "Xcode.app/Contents/version.plist" (such as "3.1.2").
| |
| | |
| ------------------------------------------------------------------------------
| |
| Variables common to all CPack generators
| |
| | |
| CPACK_ABSOLUTE_DESTINATION_FILES
| |
| List of files which have been installed using an ABSOLUTE DESTINATION
| |
| path.
| |
| | |
| This variable is a Read-Only variable which is set internally by CPack
| |
| during installation and before packaging using
| |
| CMAKE_ABSOLUTE_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_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 as a built-in default value for this variable.
| |
| E.g. Archive generators (ZIP, TGZ, ...) includes the top level
| |
| whereas RPM or DEB don't. The user may override the default value byt
| |
| setting this variable.
| |
| | |
| There is a similar variable
| |
| CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORYwhich may be used to
| |
| override the behavior for the componentpackaging case which may have
| |
| different default value forhistorical (now backward compatibility)
| |
| 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 Component,
| |
| 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>_COMPONENT_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 module 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 executable
| |
| 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.
| |
| | |
| | |
| 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 installer
| |
| (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 appropriate 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 packaging.
| |
| | |
| DESTDIR means DESTination DIRectory. It is commonly used by makefile
| |
| users in order to install software at non-default location. It is a
| |
| basic relocation mechanism. 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". 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. Nevertheless, if
| |
| CPACK_SET_DESTDIR is set then CPack will set DESTDIR before doing the
| |
| local install. The most noticeable difference is that without
| |
| CPACK_SET_DESTDIR, CPack uses CPACK_PACKAGING_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 necessary)
| |
| 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 module 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 DESTINATION
| |
| is encountered.
| |
| | |
| This variable triggers the definition of
| |
| CMAKE_WARN_ON_ABSOLUTE_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 contains 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 component-aware
| |
| CPack generators.
| |
| | |
| Some generators like RPM or ARCHIVE family (TGZ, ZIP, ...) generates several
| |
| packages files when asked for component packaging. 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>_CREATE_STATIC_LIBRARY on
| |
| some platforms in order to support large object counts. See also
| |
| CMAKE_<LANG>_ARCHIVE_CREATE and CMAKE_<LANG>_ARCHIVE_FINISH.
| |
| | |
| CMAKE_<LANG>_ARCHIVE_CREATE
| |
| Rule variable to create a new static archive.
| |
| | |
| This is a rule variable that tells CMake how to create a static
| |
| archive. It is used in place of CMAKE_<LANG>_CREATE_STATIC_LIBRARY on
| |
| some platforms in order to support large object counts. See also
| |
| CMAKE_<LANG>_ARCHIVE_APPEND and CMAKE_<LANG>_ARCHIVE_FINISH.
| |
| | |
| CMAKE_<LANG>_ARCHIVE_FINISH
| |
| Rule variable to finish an existing static archive.
| |
| | |
| This is a rule variable that tells CMake how to finish a static
| |
| archive. It is used in place of CMAKE_<LANG>_CREATE_STATIC_LIBRARY on
| |
| some platforms in order to support large object counts. See also
| |
| CMAKE_<LANG>_ARCHIVE_CREATE and CMAKE_<LANG>_ARCHIVE_APPEND.
| |
| | |
| CMAKE_<LANG>_COMPILER
| |
| The full path to the compiler for LANG.
| |
| | |
| This is the command that will be used as the <LANG> compiler. Once
| |
| set, you can not change this variable.
| |
| | |
| CMAKE_<LANG>_COMPILER_ABI
| |
| An internal variable subject to change.
| |
| | |
| This is used in determining the compiler ABI and is subject to change.
| |
| | |
| CMAKE_<LANG>_COMPILER_ID
| |
| An internal variable subject to change.
| |
| | |
| This is used in determining the compiler and is subject to change.
| |
| | |
| CMAKE_<LANG>_COMPILER_LOADED
| |
| Defined to true if the language is enabled.
| |
| | |
| When language <LANG> is enabled by project() or enable_language() this
| |
| variable is defined to 1.
| |
| | |
| CMAKE_<LANG>_COMPILER_VERSION
| |
| An internal variable subject to change.
| |
| | |
| Compiler version in major[.minor[.patch[.tweak]]] format. This
| |
| variable is reserved for internal use by CMake and is not guaranteed
| |
| to be set.
| |
| | |
| CMAKE_<LANG>_COMPILE_OBJECT
| |
| Rule variable to compile a single object file.
| |
| | |
| This is a rule variable that tells CMake how to compile a single
| |
| object file for for the language <LANG>.
| |
| | |
| CMAKE_<LANG>_CREATE_SHARED_LIBRARY
| |
| Rule variable to create a shared library.
| |
| | |
| This is a rule variable that tells CMake how to create a shared
| |
| library for the language <LANG>.
| |
| | |
| CMAKE_<LANG>_CREATE_SHARED_MODULE
| |
| Rule variable to create a shared module.
| |
| | |
| This is a rule variable that tells CMake how to create a shared
| |
| library for the language <LANG>.
| |
| | |
| CMAKE_<LANG>_CREATE_STATIC_LIBRARY
| |
| Rule variable to create a static library.
| |
| | |
| This is a rule variable that tells CMake how to create a static
| |
| library for the language <LANG>.
| |
| | |
| CMAKE_<LANG>_FLAGS_DEBUG
| |
| Flags for Debug build type or configuration.
| |
| | |
| <LANG> flags used when CMAKE_BUILD_TYPE is Debug.
| |
| | |
| CMAKE_<LANG>_FLAGS_MINSIZEREL
| |
| Flags for MinSizeRel build type or configuration.
| |
| | |
| <LANG> flags used when CMAKE_BUILD_TYPE is MinSizeRel.Short for
| |
| minimum size release.
| |
| | |
| CMAKE_<LANG>_FLAGS_RELEASE
| |
| Flags for Release build type or configuration.
| |
| | |
| <LANG> flags used when CMAKE_BUILD_TYPE is Release
| |
| | |
| CMAKE_<LANG>_FLAGS_RELWITHDEBINFO
| |
| Flags for RelWithDebInfo type or configuration.
| |
| | |
| <LANG> flags used when CMAKE_BUILD_TYPE is RelWithDebInfo. Short for
| |
| Release With Debug Information.
| |
| | |
| CMAKE_<LANG>_IGNORE_EXTENSIONS
| |
| File extensions that should be ignored by the build.
| |
| | |
| This is a list of file extensions that may be part of a project for a
| |
| given 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.
| |
| | |
| 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-specific
| |
| system library search directory such as <prefix>/lib/<arch> this
| |
| variable contains the <arch> name if/as detected by CMake.
| |
| | |
| CMAKE_<LANG>_LINKER_PREFERENCE
| |
| Preference value for linker language selection.
| |
| | |
| The "linker language" for executable, shared library, and module
| |
| targets is the language whose compiler will invoke the linker. The
| |
| LINKER_LANGUAGE target property sets the language explicitly.
| |
| Otherwise, the linker language is that whose linker preference value
| |
| is highest among languages compiled and linked into the target. See
| |
| also the CMAKE_<LANG>_LINKER_PREFERENCE_PROPAGATES variable.
| |
| | |
| CMAKE_<LANG>_LINKER_PREFERENCE_PROPAGATES
| |
| True if CMAKE_<LANG>_LINKER_PREFERENCE propagates across targets.
| |
| | |
| This is used when CMake selects a linker language for a target.
| |
| Languages compiled directly into the target are always considered. A
| |
| language compiled into static libraries linked by the target is
| |
| considered if this variable is true.
| |
| | |
| CMAKE_<LANG>_LINK_EXECUTABLE
| |
| Rule variable to link and executable.
| |
| | |
| Rule variable to link and executable for the given language.
| |
| | |
| CMAKE_<LANG>_OUTPUT_EXTENSION
| |
| Extension for the output of a compile for a single file.
| |
| | |
| This is the extension for an object file for the given <LANG>. For
| |
| example .obj for C on Windows.
| |
| | |
| CMAKE_<LANG>_PLATFORM_ID
| |
| An internal variable subject to change.
| |
| | |
| This is used in determining the platform and is subject to change.
| |
| | |
| CMAKE_<LANG>_SIZEOF_DATA_PTR
| |
| Size of pointer-to-data types for language <LANG>.
| |
| | |
| This holds the size (in bytes) of pointer-to-data types in the target
| |
| platform ABI. It is defined for languages C and CXX (C++).
| |
| | |
| CMAKE_<LANG>_SOURCE_FILE_EXTENSIONS
| |
| Extensions of source files for the given language.
| |
| | |
| This is the list of extensions for a given languages source files.
| |
| | |
| CMAKE_COMPILER_IS_GNU<LANG>
| |
| True if the compiler is GNU.
| |
| | |
| If the selected <LANG> compiler is the GNU compiler then this is TRUE,
| |
| if not it is FALSE.
| |
| | |
| CMAKE_Fortran_MODDIR_DEFAULT
| |
| Fortran default module output directory.
| |
| | |
| Most Fortran compilers write .mod files to the current working
| |
| directory. For those that do not, this is set to "." and used when
| |
| the Fortran_MODULE_DIRECTORY target property is not set.
| |
| | |
| CMAKE_Fortran_MODDIR_FLAG
| |
| Fortran flag for module output directory.
| |
| | |
| This stores the flag needed to pass the value of the
| |
| Fortran_MODULE_DIRECTORY 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 language <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 whenever 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 custom .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 window
| |
| 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 normal 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-compressed)
| |
| 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 command.
| |
| | |
| CPACK_NSIS_CONTACT
| |
| Contact information for questions and comments about the installation
| |
| 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 Section,
| |
| before your install tree is
| |
| | |
| removed from the target system.
| |
| | |
| CPACK_NSIS_HELP_LINK
| |
| URL to a web site providing assistance in installing your application.
| |
| | |
| 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 application.
| |
| | |
| ------------------------------------------------------------------------------
| |
| 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_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).
| |
| | |
| | |
| 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 that Control the Build
| |
| | |
| CMAKE_<CONFIG>_POSTFIX
| |
| Default filename postfix for libraries under configuration <CONFIG>.
| |
| | |
| When a non-executable target is created its <CONFIG>_POSTFIX target
| |
| property is initialized with the value of this variable if it is set.
| |
| | |
| CMAKE_ARCHIVE_OUTPUT_DIRECTORY
| |
| Where to put all the ARCHIVE targets when built.
| |
| | |
| This variable is used to initialize the ARCHIVE_OUTPUT_DIRECTORY
| |
| property on all the targets. See that target property for additional
| |
| information.
| |
| | |
| CMAKE_AUTOMOC
| |
| Whether to handle moc automatically for Qt targets.
| |
| | |
| This variable is used to initialize the AUTOMOC property on all the
| |
| targets. See that target property for additional information.
| |
| | |
| CMAKE_AUTOMOC_MOC_OPTIONS
| |
| Additional options for moc when using automoc (see CMAKE_AUTOMOC).
| |
| | |
| This variable is used to initialize the AUTOMOC_MOC_OPTIONS property
| |
| on all the targets. See that target property for additional
| |
| information.
| |
| | |
| CMAKE_BUILD_WITH_INSTALL_RPATH
| |
| Use the install path for the RPATH
| |
| | |
| Normally CMake uses the build tree for the RPATH when building
| |
| executables etc on systems that use RPATH. When the software is
| |
| installed the executables etc are relinked by CMake to have the
| |
| install RPATH. If this variable is set to true then the software is
| |
| always built with the install path for the RPATH and does not need to
| |
| be relinked when installed.
| |
| | |
| CMAKE_DEBUG_POSTFIX
| |
| See variable CMAKE_<CONFIG>_POSTFIX.
| |
| | |
| This variable is a special case of the more-general
| |
| CMAKE_<CONFIG>_POSTFIX variable for the DEBUG configuration.
| |
| | |
| CMAKE_EXE_LINKER_FLAGS
| |
| Linker flags used to create executables.
| |
| | |
| Flags used by the linker when creating an executable.
| |
| | |
| CMAKE_EXE_LINKER_FLAGS_[CMAKE_BUILD_TYPE]
| |
| Flag used when linking an executable.
| |
| | |
| Same as CMAKE_C_FLAGS_* but used by the linker when creating
| |
| executables.
| |
| | |
| CMAKE_Fortran_FORMAT
| |
| Set to FIXED or FREE to indicate the Fortran source layout.
| |
| | |
| This variable is used to initialize the Fortran_FORMAT property on all
| |
| the targets. See that target property for additional information.
| |
| | |
| CMAKE_Fortran_MODULE_DIRECTORY
| |
| Fortran module output directory.
| |
| | |
| This variable is used to initialize the Fortran_MODULE_DIRECTORY
| |
| property on all the targets. See that target property for additional
| |
| information.
| |
| | |
| CMAKE_GNUtoMS
| |
| Convert GNU import libraries (.dll.a) to MS format (.lib).
| |
| | |
| This variable is used to initialize the GNUtoMS property on targets
| |
| when they are created. See that target property for additional
| |
| information.
| |
| | |
| CMAKE_INCLUDE_CURRENT_DIR
| |
| Automatically add the current source- and build directories to the
| |
| include path.
| |
| | |
| If this variable is enabled, CMake automatically adds in each
| |
| directory ${CMAKE_CURRENT_SOURCE_DIR} and ${CMAKE_CURRENT_BINARY_DIR}
| |
| to the include path for this directory. These additional include
| |
| directories do not propagate down to subdirectories. 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_INSTALL_NAME_DIR
| |
| Mac OSX directory name for installed targets.
| |
| | |
| CMAKE_INSTALL_NAME_DIR is used to initialize the INSTALL_NAME_DIR
| |
| property on all targets. See that target property for more
| |
| information.
| |
| | |
| CMAKE_INSTALL_RPATH
| |
| The rpath to use for installed targets.
| |
| | |
| A semicolon-separated list specifying the rpath to use in installed
| |
| targets (for platforms that support it). This is used to initialize
| |
| the target property INSTALL_RPATH for all targets.
| |
| | |
| CMAKE_INSTALL_RPATH_USE_LINK_PATH
| |
| Add paths to linker search and installed rpath.
| |
| | |
| CMAKE_INSTALL_RPATH_USE_LINK_PATH is a boolean that if set to true
| |
| will append directories in the linker search path and outside the
| |
| project to the INSTALL_RPATH. This is used to initialize the target
| |
| property INSTALL_RPATH_USE_LINK_PATH for all targets.
| |
| | |
| CMAKE_LIBRARY_OUTPUT_DIRECTORY
| |
| Where to put all the LIBRARY targets when built.
| |
| | |
| This variable is used to initialize the LIBRARY_OUTPUT_DIRECTORY
| |
| property on all the targets. See that target property for additional
| |
| information.
| |
| | |
| CMAKE_LIBRARY_PATH_FLAG
| |
| The flag used to add a library search path to a compiler.
| |
| | |
| The flag used to specify a library directory to the compiler. On most
| |
| compilers this is "-L".
| |
| | |
| CMAKE_LINK_DEF_FILE_FLAG
| |
| Linker flag used to specify a .def file for dll creation.
| |
| | |
| The flag used to add a .def file when creating a dll on Windows, this
| |
| is only defined on Windows.
| |
| | |
| CMAKE_LINK_INTERFACE_LIBRARIES
| |
| Default value for LINK_INTERFACE_LIBRARIES of targets.
| |
| | |
| This variable is used to initialize the LINK_INTERFACE_LIBRARIES
| |
| property on all the targets. See that target property for additional
| |
| information.
| |
| | |
| CMAKE_LINK_LIBRARY_FILE_FLAG
| |
| Flag used to link a library specified by a path to its file.
| |
| | |
| The flag used before a library file path is given to the linker. This
| |
| is needed only on very few platforms.
| |
| | |
| CMAKE_LINK_LIBRARY_FLAG
| |
| Flag used to link a library into an executable.
| |
| | |
| The flag used to specify a library to link to an executable. On most
| |
| compilers this is "-l".
| |
| | |
| CMAKE_MACOSX_BUNDLE
| |
| Default value for MACOSX_BUNDLE of targets.
| |
| | |
| This variable is used to initialize the MACOSX_BUNDLE property on all
| |
| the targets. See that target property for additional information.
| |
| | |
| CMAKE_NO_BUILTIN_CHRPATH
| |
| Do not use the builtin ELF editor to fix RPATHs on installation.
| |
| | |
| When an ELF binary needs to have a different RPATH after installation
| |
| than it does in the build tree, CMake uses a builtin editor to change
| |
| the RPATH in the installed copy. If this variable is set to true then
| |
| CMake will relink the binary before installation instead of using its
| |
| builtin editor.
| |
| | |
| CMAKE_POSITION_INDEPENDENT_FLAGS
| |
| Default value for POSITION_INDEPENDENT_CODE of targets.
| |
| | |
| This variable is used to initialize the POSITION_INDEPENDENT_CODE
| |
| property on all the targets. See that target property for additional
| |
| information.
| |
| | |
| CMAKE_RUNTIME_OUTPUT_DIRECTORY
| |
| Where to put all the RUNTIME targets when built.
| |
| | |
| This variable is used to initialize the RUNTIME_OUTPUT_DIRECTORY
| |
| property on all the targets. See that target property for additional
| |
| information.
| |
| | |
| CMAKE_SKIP_BUILD_RPATH
| |
| Do not include RPATHs in the build tree.
| |
| | |
| Normally CMake uses the build tree for the RPATH when building
| |
| executables etc on systems that use RPATH. When the software is
| |
| installed the executables etc are relinked by CMake to have the
| |
| install RPATH. If this variable is set to true then the software is
| |
| always built with no RPATH.
| |
| | |
| CMAKE_SKIP_INSTALL_RPATH
| |
| Do not include RPATHs in the install tree.
| |
| | |
| Normally CMake uses the build tree for the RPATH when building
| |
| executables etc on systems that use RPATH. When the software is
| |
| installed the executables etc are relinked by CMake to have the
| |
| install RPATH. If this variable is set to true then the software is
| |
| always installed without RPATH, even if RPATH is enabled when
| |
| building. This can be useful for example to allow running tests from
| |
| the build directory with RPATH enabled before the installation step.
| |
| To omit RPATH in both the build and install steps, use
| |
| CMAKE_SKIP_RPATH instead.
| |
| | |
| CMAKE_TRY_COMPILE_CONFIGURATION
| |
| Build configuration used for try_compile and try_run projects.
| |
| | |
| Projects built by try_compile and try_run are built synchronously
| |
| during the CMake configuration step. Therefore a specific build
| |
| configuration must be chosen even if the generated build system
| |
| supports multiple configurations.
| |
| | |
| CMAKE_USE_RELATIVE_PATHS
| |
| Use relative paths (May not work!).
| |
| | |
| If this is set to TRUE, then the CMake will use relative paths between
| |
| the source and binary tree. This option does not work for more
| |
| complicated projects, and relative paths are used when possible. In
| |
| general, it is not possible to move CMake generated makefiles to a
| |
| different location regardless of the value of this variable.
| |
| | |
| CMAKE_WIN32_EXECUTABLE
| |
| Default value for WIN32_EXECUTABLE of targets.
| |
| | |
| This variable is used to initialize the WIN32_EXECUTABLE property on
| |
| all the targets. See that target property for additional information.
| |
| | |
| EXECUTABLE_OUTPUT_PATH
| |
| Old executable location variable.
| |
| | |
| The target property RUNTIME_OUTPUT_DIRECTORY supercedes this variable
| |
| for a target if it is set. Executable targets are otherwise placed in
| |
| this directory.
| |
| | |
| LIBRARY_OUTPUT_PATH
| |
| Old library location variable.
| |
| | |
| The target properties ARCHIVE_OUTPUT_DIRECTORY,
| |
| LIBRARY_OUTPUT_DIRECTORY, and RUNTIME_OUTPUT_DIRECTORY supercede this
| |
| variable for a target if they are set. Library targets are otherwise
| |
| placed in this directory.
| |
| | |
| ------------------------------------------------------------------------------
| |
| Variables that Provide Information
| |
| | |
| CMAKE_AR
| |
| Name of archiving tool for static libraries.
| |
| | |
| This specifies name of the program that creates archive or static
| |
| libraries.
| |
| | |
| CMAKE_ARGC
| |
| Number of command line arguments passed to CMake in script mode.
| |
| | |
| When run in -P script mode, CMake sets this variable to the number of
| |
| command line arguments. See also CMAKE_ARGV0, 1, 2 ...
| |
| | |
| CMAKE_ARGV0
| |
| Command line argument passed to CMake in script mode.
| |
| | |
| When run in -P script mode, CMake sets this variable to the first
| |
| command line argument. It then also sets CMAKE_ARGV1, CMAKE_ARGV2,
| |
| ... and so on, up to the 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 Studio 6, the
| |
| CMAKE_BUILD_TOOL will be set to msdev, for Unix makefiles it will be
| |
| set to make or gmake, and for Visual Studio 7 it set to devenv. For
| |
| Nmake Makefiles the value is nmake. This can be useful for adding
| |
| special flags and commands based on the final build environment.
| |
| | |
| CMAKE_CACHEFILE_DIR
| |
| The directory with the CMakeCache.txt file.
| |
| | |
| This is the full path to the directory that has the CMakeCache.txt
| |
| file in it. This is the same as CMAKE_BINARY_DIR.
| |
| | |
| CMAKE_CACHE_MAJOR_VERSION
| |
| Major version of CMake used to create the CMakeCache.txt file
| |
| | |
| This is stores the major version of CMake used to write a CMake cache
| |
| file. It is only different when a different version of CMake is run
| |
| on a previously created cache file.
| |
| | |
| CMAKE_CACHE_MINOR_VERSION
| |
| Minor version of CMake used to create the CMakeCache.txt file
| |
| | |
| This is stores the minor version of CMake used to write a CMake cache
| |
| file. It is only different when a different version of CMake is run
| |
| on a previously created cache file.
| |
| | |
| CMAKE_CACHE_PATCH_VERSION
| |
| Patch version of CMake used to create the CMakeCache.txt file
| |
| | |
| This is stores the patch version of CMake used to write a CMake cache
| |
| file. It is only different when a different version of CMake is run
| |
| on a previously created cache file.
| |
| | |
| CMAKE_CFG_INTDIR
| |
| Build-time reference to per-configuration output subdirectory.
| |
| | |
| For native build systems supporting multiple configurations in the
| |
| build tree (such as Visual Studio and Xcode), the value is a reference
| |
| to a build-time variable specifying the name of the per-configuration
| |
| output subdirectory. On Makefile 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 purpose but
| |
| has been left for compatibility with existing projects. Instead
| |
| add_custom_command() recognizes executable target names in its COMMAND
| |
| option, so "${CMAKE_CURRENT_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_subdirectory will
| |
| create a binary directory in the build tree, and as it is being
| |
| processed this variable will be set. For in-source builds this is the
| |
| current source directory being processed.
| |
| | |
| CMAKE_CURRENT_LIST_DIR
| |
| Full directory of the listfile currently being processed.
| |
| | |
| As CMake processes the listfiles in your project this variable will
| |
| always be set to the directory where the listfile which is currently
| |
| being processed (CMAKE_CURRENT_LIST_FILE) is located. The value has
| |
| dynamic scope. When CMake starts processing commands in a source file
| |
| it sets this variable to the directory where this file is located.
| |
| When CMake finishes processing commands from the file it restores the
| |
| previous value. Therefore the value of the variable inside a macro or
| |
| function is the directory of the file invoking the bottom-most entry
| |
| on the call stack, not the directory of the file containing the macro
| |
| or function definition.
| |
| | |
| See also CMAKE_CURRENT_LIST_FILE.
| |
| | |
| CMAKE_CURRENT_LIST_FILE
| |
| Full path to the listfile currently being processed.
| |
| | |
| As CMake processes the listfiles in your project this variable will
| |
| always be set to the one currently being processed. The value has
| |
| dynamic scope. When CMake starts processing commands in a source file
| |
| it sets this variable to the location of the file. When CMake
| |
| finishes processing commands from the file it restores the previous
| |
| value. Therefore the value of the variable inside a macro or function
| |
| is the file invoking the bottom-most entry on the call stack, not the
| |
| file containing the macro or function definition.
| |
| | |
| See also CMAKE_PARENT_LIST_FILE.
| |
| | |
| CMAKE_CURRENT_LIST_LINE
| |
| The line number of the current file being processed.
| |
| | |
| This is the line number of the file currently being processed by
| |
| cmake.
| |
| | |
| CMAKE_CURRENT_SOURCE_DIR
| |
| The path to the source directory currently being processed.
| |
| | |
| This the full path to the source directory that is currently being
| |
| processed by cmake.
| |
| | |
| CMAKE_DL_LIBS
| |
| Name of library containing dlopen and dlcose.
| |
| | |
| The name of the library that has dlopen and dlclose in it, usually
| |
| -ldl on most UNIX machines.
| |
| | |
| CMAKE_EDIT_COMMAND
| |
| Full path to cmake-gui or ccmake.
| |
| | |
| This is the full path to the CMake executable that can graphically
| |
| edit the cache. For example, cmake-gui, ccmake, or cmake -i.
| |
| | |
| CMAKE_EXECUTABLE_SUFFIX
| |
| The suffix for executables on this platform.
| |
| | |
| The suffix to use for the end of an executable if any, .exe on
| |
| Windows.
| |
| | |
| CMAKE_EXECUTABLE_SUFFIX_<LANG> overrides this for language <LANG>.
| |
| | |
| CMAKE_EXTRA_GENERATOR
| |
| The extra generator used to build the project.
| |
| | |
| When using the Eclipse, CodeBlocks or KDevelop generators, CMake
| |
| generates 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 recognize
| |
| external shared library files during analysis of libraries linked by a
| |
| target.
| |
| | |
| CMAKE_GENERATOR
| |
| The generator used to build the project.
| |
| | |
| The name of the generator that is being used to generate the build
| |
| files. (e.g. "Unix Makefiles", "Visual Studio 6", etc.)
| |
| | |
| CMAKE_HOME_DIRECTORY
| |
| Path to top of source tree.
| |
| | |
| This is the path to the top level of the source tree.
| |
| | |
| CMAKE_IMPORT_LIBRARY_PREFIX
| |
| The prefix for import libraries that you link to.
| |
| | |
| The prefix to use for the name of an import library if used on this
| |
| platform.
| |
| | |
| CMAKE_IMPORT_LIBRARY_PREFIX_<LANG> overrides this for language <LANG>.
| |
| | |
| CMAKE_IMPORT_LIBRARY_SUFFIX
| |
| The suffix for import libraries that you link to.
| |
| | |
| The suffix to use for the end of an import library if used on this
| |
| platform.
| |
| | |
| CMAKE_IMPORT_LIBRARY_SUFFIX_<LANG> overrides this for language <LANG>.
| |
| | |
| CMAKE_LINK_LIBRARY_SUFFIX
| |
| The suffix for libraries that you link to.
| |
| | |
| The suffix to use for the end of a library, .lib on Windows.
| |
| | |
| CMAKE_MAJOR_VERSION
| |
| The Major version of cmake (i.e. the 2 in 2.X.X)
| |
| | |
| This specifies the major version of the CMake executable being run.
| |
| | |
| CMAKE_MAKE_PROGRAM
| |
| See CMAKE_BUILD_TOOL.
| |
| | |
| This variable is around for backwards compatibility, see
| |
| CMAKE_BUILD_TOOL.
| |
| | |
| CMAKE_MINOR_VERSION
| |
| The Minor version of cmake (i.e. the 4 in X.4.X).
| |
| | |
| This specifies the minor version of the CMake executable being run.
| |
| | |
| CMAKE_PARENT_LIST_FILE
| |
| Full path to the parent listfile of the one currently being processed.
| |
| | |
| As CMake processes the listfiles in your project this variable will
| |
| always be set to the listfile that included or somehow invoked the one
| |
| currently being processed. See also CMAKE_CURRENT_LIST_FILE.
| |
| | |
| CMAKE_PATCH_VERSION
| |
| The patch version of cmake (i.e. the 3 in X.X.3).
| |
| | |
| This specifies the patch version of the CMake executable being run.
| |
| | |
| CMAKE_PROJECT_NAME
| |
| The name of the current project.
| |
| | |
| This specifies name of the current project from the closest inherited
| |
| PROJECT 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 format:
| |
| ${CMAKE_ROOT}/Modules
| |
| | |
| CMAKE_SCRIPT_MODE_FILE
| |
| Full path to the -P script file currently being processed.
| |
| | |
| When run in -P script mode, CMake sets this variable to the full path
| |
| of the script file. When run to configure a CMakeLists.txt file, this
| |
| variable is not set.
| |
| | |
| CMAKE_SHARED_LIBRARY_PREFIX
| |
| The prefix for shared libraries that you link to.
| |
| | |
| The prefix to use for the name of a shared library, lib on UNIX.
| |
| | |
| CMAKE_SHARED_LIBRARY_PREFIX_<LANG> overrides this for language <LANG>.
| |
| | |
| CMAKE_SHARED_LIBRARY_SUFFIX
| |
| The suffix for shared libraries that you link to.
| |
| | |
| The suffix to use for the end of a shared library, .dll on Windows.
| |
| | |
| CMAKE_SHARED_LIBRARY_SUFFIX_<LANG> overrides this for language <LANG>.
| |
| | |
| CMAKE_SHARED_MODULE_PREFIX
| |
| The prefix for loadable modules that you link to.
| |
| | |
| The prefix to use for the name of a loadable module on this platform.
| |
| | |
| CMAKE_SHARED_MODULE_PREFIX_<LANG> overrides this for language <LANG>.
| |
| | |
| CMAKE_SHARED_MODULE_SUFFIX
| |
| The suffix for shared libraries that you link to.
| |
| | |
| The suffix to use for the end of a loadable module on this platform
| |
| | |
| CMAKE_SHARED_MODULE_SUFFIX_<LANG> overrides this for language <LANG>.
| |
| | |
| CMAKE_SIZEOF_VOID_P
| |
| Size of a void pointer.
| |
| | |
| This is set to the size of a pointer on the machine, and is determined
| |
| by a try compile. If a 64 bit size is found, then the library search
| |
| path is modified to look for 64 bit libraries first.
| |
| | |
| CMAKE_SKIP_RPATH
| |
| If true, do not add run time path information.
| |
| | |
| If this is set to TRUE, then the rpath information is not added to
| |
| compiled executables. The default is to add rpath information if the
| |
| platform supports it. This allows for easy running from the build
| |
| tree. To omit RPATH in the install step, but not the build step, use
| |
| CMAKE_SKIP_INSTALL_RPATH instead.
| |
| | |
| CMAKE_SOURCE_DIR
| |
| The path to the top level of the source tree.
| |
| | |
| This is the full path to the top level of the current CMake source
| |
| tree. For an in-source build, this would be the same as
| |
| CMAKE_BINARY_DIR.
| |
| | |
| CMAKE_STANDARD_LIBRARIES
| |
| Libraries linked into every executable and shared library.
| |
| | |
| This is the list of libraries that are linked into all executables and
| |
| libraries.
| |
| | |
| CMAKE_STATIC_LIBRARY_PREFIX
| |
| The prefix for static libraries that you link to.
| |
| | |
| The prefix to use for the name of a static library, lib on UNIX.
| |
| | |
| CMAKE_STATIC_LIBRARY_PREFIX_<LANG> overrides this for language <LANG>.
| |
| | |
| CMAKE_STATIC_LIBRARY_SUFFIX
| |
| The suffix for static libraries that you link to.
| |
| | |
| The suffix to use for the end of a static library, .lib on Windows.
| |
| | |
| CMAKE_STATIC_LIBRARY_SUFFIX_<LANG> overrides this for language <LANG>.
| |
| | |
| CMAKE_TWEAK_VERSION
| |
| The tweak version of cmake (i.e. the 1 in X.X.X.1).
| |
| | |
| This specifies the tweak version of the CMake executable being run.
| |
| Releases use tweak < 20000000 and development versions use the date
| |
| format CCYYMMDD for the tweak level.
| |
| | |
| CMAKE_USING_VC_FREE_TOOLS
| |
| True if free visual studio tools being used.
| |
| | |
| This is set to true if the compiler is Visual Studio free tools.
| |
| | |
| CMAKE_VERBOSE_MAKEFILE
| |
| Create verbose makefiles if on.
| |
| | |
| This variable defaults to false. You can set this variable to true to
| |
| make CMake produce verbose makefiles that show each command line as it
| |
| is used.
| |
| | |
| CMAKE_VERSION
| |
| The full version of cmake in major.minor.patch[.tweak[-id]] format.
| |
| | |
| This specifies the full version of the CMake executable being run.
| |
| This variable is defined by versions 2.6.3 and higher. See variables
| |
| CMAKE_MAJOR_VERSION, CMAKE_MINOR_VERSION, CMAKE_PATCH_VERSION, and
| |
| CMAKE_TWEAK_VERSION for individual version components. The [-id]
| |
| component appears in non-release versions and may be arbitrary text.
| |
| | |
| PROJECT_BINARY_DIR
| |
| Full path to build directory for project.
| |
| | |
| This is the binary directory of the most recent PROJECT command.
| |
| | |
| PROJECT_NAME
| |
| Name of the project given to the project command.
| |
| | |
| This is the name given to the most recent PROJECT command.
| |
| | |
| PROJECT_SOURCE_DIR
| |
| Top level source directory for the current project.
| |
| | |
| This is the source directory of the most recent PROJECT command.
| |
| | |
| [Project name]_BINARY_DIR
| |
| Top level binary directory for the named project.
| |
| | |
| A variable is created with the name used in the PROJECT command, and
| |
| is the binary directory for the project. This can be useful when
| |
| SUBDIR is used to connect 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 useful when
| |
| add_subdirectory is used to connect several projects.
| |
| | |
| ------------------------------------------------------------------------------
| |
| Copyright
| |
| | |
| Copyright 2000-2009 Kitware, Inc., Insight Software Consortium. All rights
| |
| reserved.
| |
| | |
| Redistribution and use in source and binary forms, with or without
| |
| modification, 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 permission.
| |
| | |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
| |
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
| |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
| |
| ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
| |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
| |
| CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
| |
| 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
| |
| | |
| The following resources are available to get help using CMake:
| |
| | |
| Home Page
| |
| http://www.cmake.org
| |
| | |
| The primary starting point for learning about CMake.
| |
| | |
| Frequently Asked Questions
| |
| http://www.cmake.org/Wiki/CMake_FAQ
| |
| | |
| A Wiki is provided containing answers to frequently asked questions.
| |
| | |
| Online Documentation
| |
| http://www.cmake.org/HTML/Documentation.html
| |
| | |
| Links to available documentation may be found on this web page.
| |
| | |
| Mailing List
| |
| http://www.cmake.org/HTML/MailingLists.html
| |
| | |
| For help and discussion about using cmake, a mailing list is provided
| |
| at cmake@cmake.org. The list is member-post-only but one may sign up
| |
| on the CMake web page. Please first read the full documentation at
| |
| http://www.cmake.org before posting questions to the list.
| |
| | |
| Summary of helpful links:
| |
| | |
| Home: http://www.cmake.org
| |
| Docs: http://www.cmake.org/HTML/Documentation.html
| |
| Mail: http://www.cmake.org/HTML/MailingLists.html
| |
| FAQ: http://www.cmake.org/Wiki/CMake_FAQ
| |
| | |
| </pre>
| |
