diff options
Diffstat (limited to 'Help/policy')
| -rw-r--r-- | Help/policy/CMP0000.rst | 30 | ||||
| -rw-r--r-- | Help/policy/CMP0001.rst | 19 | ||||
| -rw-r--r-- | Help/policy/CMP0002.rst | 26 | ||||
| -rw-r--r-- | Help/policy/CMP0003.rst | 102 | ||||
| -rw-r--r-- | Help/policy/CMP0004.rst | 23 | ||||
| -rw-r--r-- | Help/policy/CMP0005.rst | 24 | ||||
| -rw-r--r-- | Help/policy/CMP0006.rst | 22 | ||||
| -rw-r--r-- | Help/policy/CMP0007.rst | 15 | ||||
| -rw-r--r-- | Help/policy/CMP0008.rst | 32 | ||||
| -rw-r--r-- | Help/policy/CMP0009.rst | 19 | ||||
| -rw-r--r-- | Help/policy/CMP0010.rst | 15 | ||||
| -rw-r--r-- | Help/policy/CMP0011.rst | 22 | ||||
| -rw-r--r-- | Help/policy/CMP0012.rst | 25 | ||||
| -rw-r--r-- | Help/policy/CMP0013.rst | 19 | ||||
| -rw-r--r-- | Help/policy/CMP0014.rst | 15 | ||||
| -rw-r--r-- | Help/policy/CMP0015.rst | 17 | ||||
| -rw-r--r-- | Help/policy/CMP0016.rst | 13 | ||||
| -rw-r--r-- | Help/policy/CMP0017.rst | 19 | ||||
| -rw-r--r-- | Help/policy/CMP0018.rst | 32 | ||||
| -rw-r--r-- | Help/policy/CMP0019.rst | 20 | ||||
| -rw-r--r-- | Help/policy/CMP0020.rst | 25 | ||||
| -rw-r--r-- | Help/policy/CMP0021.rst | 18 | ||||
| -rw-r--r-- | Help/policy/CMP0022.rst | 33 | ||||
| -rw-r--r-- | Help/policy/CMP0023.rst | 33 | ||||
| -rw-r--r-- | Help/policy/CMP0024.rst | 22 | ||||
| -rw-r--r-- | Help/policy/CMP0025.rst | 21 | ||||
| -rw-r--r-- | Help/policy/CMP0026.rst | 25 |
27 files changed, 686 insertions, 0 deletions
diff --git a/Help/policy/CMP0000.rst b/Help/policy/CMP0000.rst new file mode 100644 index 0000000..9fbf842 --- /dev/null +++ b/Help/policy/CMP0000.rst @@ -0,0 +1,30 @@ +CMP0000 +------- + +A minimum required CMake version must be specified. + +CMake requires that projects specify the version of CMake to which +they have been written. This policy has been put in place so users +trying to build the project may be told when they need to update their +CMake. Specifying a version also helps the project build with CMake +versions newer than that specified. Use the cmake_minimum_required +command at the top of your main CMakeLists.txt file: + +:: + + cmake_minimum_required(VERSION <major>.<minor>) + +where "<major>.<minor>" is the version of CMake you want to support +(such as "2.6"). The command will ensure that at least the given +version of CMake is running and help newer versions be compatible with +the project. See documentation of cmake_minimum_required for details. + +Note that the command invocation must appear in the CMakeLists.txt +file itself; a call in an included file is not sufficient. However, +the cmake_policy command may be called to set policy CMP0000 to OLD or +NEW behavior explicitly. The OLD behavior is to silently ignore the +missing invocation. The NEW behavior is to issue an error instead of +a warning. An included file may set CMP0000 explicitly to affect how +this policy is enforced for the main CMakeLists.txt file. + +This policy was introduced in CMake version 2.6.0. diff --git a/Help/policy/CMP0001.rst b/Help/policy/CMP0001.rst new file mode 100644 index 0000000..344f1e2 --- /dev/null +++ b/Help/policy/CMP0001.rst @@ -0,0 +1,19 @@ +CMP0001 +------- + +CMAKE_BACKWARDS_COMPATIBILITY should no longer be used. + +The OLD behavior is to check CMAKE_BACKWARDS_COMPATIBILITY and present +it to the user. The NEW behavior is to ignore +CMAKE_BACKWARDS_COMPATIBILITY completely. + +In CMake 2.4 and below the variable CMAKE_BACKWARDS_COMPATIBILITY was +used to request compatibility with earlier versions of CMake. In +CMake 2.6 and above all compatibility issues are handled by policies +and the cmake_policy command. However, CMake must still check +CMAKE_BACKWARDS_COMPATIBILITY for projects written for CMake 2.4 and +below. + +This policy was introduced in CMake version 2.6.0. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0002.rst b/Help/policy/CMP0002.rst new file mode 100644 index 0000000..2c15bd4 --- /dev/null +++ b/Help/policy/CMP0002.rst @@ -0,0 +1,26 @@ +CMP0002 +------- + +Logical target names must be globally unique. + +Targets names created with add_executable, add_library, or +add_custom_target are logical build target names. Logical target +names must be globally unique because: + +:: + + - Unique names may be referenced unambiguously both in CMake + code and on make tool command lines. + - Logical names are used by Xcode and VS IDE generators + to produce meaningful project names for the targets. + +The logical name of executable and library targets does not have to +correspond to the physical file names built. Consider using the +OUTPUT_NAME target property to create two targets with the same +physical name while keeping logical names distinct. Custom targets +must simply have globally unique names (unless one uses the global +property ALLOW_DUPLICATE_CUSTOM_TARGETS with a Makefiles generator). + +This policy was introduced in CMake version 2.6.0. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0003.rst b/Help/policy/CMP0003.rst new file mode 100644 index 0000000..27b83f8 --- /dev/null +++ b/Help/policy/CMP0003.rst @@ -0,0 +1,102 @@ +CMP0003 +------- + +Libraries linked via full path no longer produce linker search paths. + +This policy affects how libraries whose full paths are NOT known are +found at link time, but was created due to a change in how CMake deals +with libraries whose full paths are known. Consider the code + +:: + + target_link_libraries(myexe /path/to/libA.so) + +CMake 2.4 and below implemented linking to libraries whose full paths +are known by splitting them on the link line into separate components +consisting of the linker search path and the library name. The +example code might have produced something like + +:: + + ... -L/path/to -lA ... + +in order to link to library A. An analysis was performed to order +multiple link directories such that the linker would find library A in +the desired location, but there are cases in which this does not work. +CMake versions 2.6 and above use the more reliable approach of passing +the full path to libraries directly to the linker in most cases. The +example code now produces something like + +:: + + ... /path/to/libA.so .... + +Unfortunately this change can break code like + +:: + + target_link_libraries(myexe /path/to/libA.so B) + +where "B" is meant to find "/path/to/libB.so". This code is wrong +because the user is asking the linker to find library B but has not +provided a linker search path (which may be added with the +link_directories command). However, with the old linking +implementation the code would work accidentally because the linker +search path added for library A allowed library B to be found. + +In order to support projects depending on linker search paths added by +linking to libraries with known full paths, the OLD behavior for this +policy will add the linker search paths even though they are not +needed for their own libraries. When this policy is set to OLD, CMake +will produce a link line such as + +:: + + ... -L/path/to /path/to/libA.so -lB ... + +which will allow library B to be found as it was previously. When +this policy is set to NEW, CMake will produce a link line such as + +:: + + ... /path/to/libA.so -lB ... + +which more accurately matches what the project specified. + +The setting for this policy used when generating the link line is that +in effect when the target is created by an add_executable or +add_library command. For the example described above, the code + +:: + + cmake_policy(SET CMP0003 OLD) # or cmake_policy(VERSION 2.4) + add_executable(myexe myexe.c) + target_link_libraries(myexe /path/to/libA.so B) + +will work and suppress the warning for this policy. It may also be +updated to work with the corrected linking approach: + +:: + + cmake_policy(SET CMP0003 NEW) # or cmake_policy(VERSION 2.6) + link_directories(/path/to) # needed to find library B + add_executable(myexe myexe.c) + target_link_libraries(myexe /path/to/libA.so B) + +Even better, library B may be specified with a full path: + +:: + + add_executable(myexe myexe.c) + target_link_libraries(myexe /path/to/libA.so /path/to/libB.so) + +When all items on the link line have known paths CMake does not check +this policy so it has no effect. + +Note that the warning for this policy will be issued for at most one +target. This avoids flooding users with messages for every target +when setting the policy once will probably fix all targets. + +This policy was introduced in CMake version 2.6.0. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0004.rst b/Help/policy/CMP0004.rst new file mode 100644 index 0000000..80045f5 --- /dev/null +++ b/Help/policy/CMP0004.rst @@ -0,0 +1,23 @@ +CMP0004 +------- + +Libraries linked may not have leading or trailing whitespace. + +CMake versions 2.4 and below silently removed leading and trailing +whitespace from libraries linked with code like + +:: + + target_link_libraries(myexe " A ") + +This could lead to subtle errors in user projects. + +The OLD behavior for this policy is to silently remove leading and +trailing whitespace. The NEW behavior for this policy is to diagnose +the existence of such whitespace as an error. The setting for this +policy used when checking the library names is that in effect when the +target is created by an add_executable or add_library command. + +This policy was introduced in CMake version 2.6.0. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0005.rst b/Help/policy/CMP0005.rst new file mode 100644 index 0000000..c11a9e6 --- /dev/null +++ b/Help/policy/CMP0005.rst @@ -0,0 +1,24 @@ +CMP0005 +------- + +Preprocessor definition values are now escaped automatically. + +This policy determines whether or not CMake should generate escaped +preprocessor definition values added via add_definitions. CMake +versions 2.4 and below assumed that only trivial values would be given +for macros in add_definitions calls. It did not attempt to escape +non-trivial values such as string literals in generated build rules. +CMake versions 2.6 and above support escaping of most values, but +cannot assume the user has not added escapes already in an attempt to +work around limitations in earlier versions. + +The OLD behavior for this policy is to place definition values given +to add_definitions directly in the generated build rules without +attempting to escape anything. The NEW behavior for this policy is to +generate correct escapes for all native build tools automatically. +See documentation of the COMPILE_DEFINITIONS target property for +limitations of the escaping implementation. + +This policy was introduced in CMake version 2.6.0. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0006.rst b/Help/policy/CMP0006.rst new file mode 100644 index 0000000..8d1e5bd --- /dev/null +++ b/Help/policy/CMP0006.rst @@ -0,0 +1,22 @@ +CMP0006 +------- + +Installing MACOSX_BUNDLE targets requires a BUNDLE DESTINATION. + +This policy determines whether the install(TARGETS) command must be +given a BUNDLE DESTINATION when asked to install a target with the +MACOSX_BUNDLE property set. CMake 2.4 and below did not distinguish +application bundles from normal executables when installing targets. +CMake 2.6 provides a BUNDLE option to the install(TARGETS) command +that specifies rules specific to application bundles on the Mac. +Projects should use this option when installing a target with the +MACOSX_BUNDLE property set. + +The OLD behavior for this policy is to fall back to the RUNTIME +DESTINATION if a BUNDLE DESTINATION is not given. The NEW behavior +for this policy is to produce an error if a bundle target is installed +without a BUNDLE DESTINATION. + +This policy was introduced in CMake version 2.6.0. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0007.rst b/Help/policy/CMP0007.rst new file mode 100644 index 0000000..f0d8c16 --- /dev/null +++ b/Help/policy/CMP0007.rst @@ -0,0 +1,15 @@ +CMP0007 +------- + +list command no longer ignores empty elements. + +This policy determines whether the list command will ignore empty +elements in the list. CMake 2.4 and below list commands ignored all +empty elements in the list. For example, a;b;;c would have length 3 +and not 4. The OLD behavior for this policy is to ignore empty list +elements. The NEW behavior for this policy is to correctly count +empty elements in a list. + +This policy was introduced in CMake version 2.6.0. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0008.rst b/Help/policy/CMP0008.rst new file mode 100644 index 0000000..b118ece --- /dev/null +++ b/Help/policy/CMP0008.rst @@ -0,0 +1,32 @@ +CMP0008 +------- + +Libraries linked by full-path must have a valid library file name. + +In CMake 2.4 and below it is possible to write code like + +:: + + target_link_libraries(myexe /full/path/to/somelib) + +where "somelib" is supposed to be a valid library file name such as +"libsomelib.a" or "somelib.lib". For Makefile generators this +produces an error at build time because the dependency on the full +path cannot be found. For VS IDE and Xcode generators this used to +work by accident because CMake would always split off the library +directory and ask the linker to search for the library by name +(-lsomelib or somelib.lib). Despite the failure with Makefiles, some +projects have code like this and build only with VS and/or Xcode. +This version of CMake prefers to pass the full path directly to the +native build tool, which will fail in this case because it does not +name a valid library file. + +This policy determines what to do with full paths that do not appear +to name a valid library file. The OLD behavior for this policy is to +split the library name from the path and ask the linker to search for +it. The NEW behavior for this policy is to trust the given path and +pass it directly to the native build tool unchanged. + +This policy was introduced in CMake version 2.6.1. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0009.rst b/Help/policy/CMP0009.rst new file mode 100644 index 0000000..481af1a --- /dev/null +++ b/Help/policy/CMP0009.rst @@ -0,0 +1,19 @@ +CMP0009 +------- + +FILE GLOB_RECURSE calls should not follow symlinks by default. + +In CMake 2.6.1 and below, FILE GLOB_RECURSE calls would follow through +symlinks, sometimes coming up with unexpectedly large result sets +because of symlinks to top level directories that contain hundreds of +thousands of files. + +This policy determines whether or not to follow symlinks encountered +during a FILE GLOB_RECURSE call. The OLD behavior for this policy is +to follow the symlinks. The NEW behavior for this policy is not to +follow the symlinks by default, but only if FOLLOW_SYMLINKS is given +as an additional argument to the FILE command. + +This policy was introduced in CMake version 2.6.2. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0010.rst b/Help/policy/CMP0010.rst new file mode 100644 index 0000000..01699e1 --- /dev/null +++ b/Help/policy/CMP0010.rst @@ -0,0 +1,15 @@ +CMP0010 +------- + +Bad variable reference syntax is an error. + +In CMake 2.6.2 and below, incorrect variable reference syntax such as +a missing close-brace ("${FOO") was reported but did not stop +processing of CMake code. This policy determines whether a bad +variable reference is an error. The OLD behavior for this policy is +to warn about the error, leave the string untouched, and continue. +The NEW behavior for this policy is to report an error. + +This policy was introduced in CMake version 2.6.3. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0011.rst b/Help/policy/CMP0011.rst new file mode 100644 index 0000000..0f41fff --- /dev/null +++ b/Help/policy/CMP0011.rst @@ -0,0 +1,22 @@ +CMP0011 +------- + +Included scripts do automatic cmake_policy PUSH and POP. + +In CMake 2.6.2 and below, CMake Policy settings in scripts loaded by +the include() and find_package() commands would affect the includer. +Explicit invocations of cmake_policy(PUSH) and cmake_policy(POP) were +required to isolate policy changes and protect the includer. While +some scripts intend to affect the policies of their includer, most do +not. In CMake 2.6.3 and above, include() and find_package() by +default PUSH and POP an entry on the policy stack around an included +script, but provide a NO_POLICY_SCOPE option to disable it. This +policy determines whether or not to imply NO_POLICY_SCOPE for +compatibility. The OLD behavior for this policy is to imply +NO_POLICY_SCOPE for include() and find_package() commands. The NEW +behavior for this policy is to allow the commands to do their default +cmake_policy PUSH and POP. + +This policy was introduced in CMake version 2.6.3. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0012.rst b/Help/policy/CMP0012.rst new file mode 100644 index 0000000..7a749bf --- /dev/null +++ b/Help/policy/CMP0012.rst @@ -0,0 +1,25 @@ +CMP0012 +------- + +if() recognizes numbers and boolean constants. + +In CMake versions 2.6.4 and lower the if() command implicitly +dereferenced arguments corresponding to variables, even those named +like numbers or boolean constants, except for 0 and 1. Numbers and +boolean constants such as true, false, yes, no, on, off, y, n, +notfound, ignore (all case insensitive) were recognized in some cases +but not all. For example, the code "if(TRUE)" might have evaluated as +false. Numbers such as 2 were recognized only in boolean expressions +like "if(NOT 2)" (leading to false) but not as a single-argument like +"if(2)" (also leading to false). Later versions of CMake prefer to +treat numbers and boolean constants literally, so they should not be +used as variable names. + +The OLD behavior for this policy is to implicitly dereference +variables named like numbers and boolean constants. The NEW behavior +for this policy is to recognize numbers and boolean constants without +dereferencing variables with such names. + +This policy was introduced in CMake version 2.8.0. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0013.rst b/Help/policy/CMP0013.rst new file mode 100644 index 0000000..e99997b --- /dev/null +++ b/Help/policy/CMP0013.rst @@ -0,0 +1,19 @@ +CMP0013 +------- + +Duplicate binary directories are not allowed. + +CMake 2.6.3 and below silently permitted add_subdirectory() calls to +create the same binary directory multiple times. During build system +generation files would be written and then overwritten in the build +tree and could lead to strange behavior. CMake 2.6.4 and above +explicitly detect duplicate binary directories. CMake 2.6.4 always +considers this case an error. In CMake 2.8.0 and above this policy +determines whether or not the case is an error. The OLD behavior for +this policy is to allow duplicate binary directories. The NEW +behavior for this policy is to disallow duplicate binary directories +with an error. + +This policy was introduced in CMake version 2.8.0. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0014.rst b/Help/policy/CMP0014.rst new file mode 100644 index 0000000..37178d1 --- /dev/null +++ b/Help/policy/CMP0014.rst @@ -0,0 +1,15 @@ +CMP0014 +------- + +Input directories must have CMakeLists.txt. + +CMake versions before 2.8 silently ignored missing CMakeLists.txt +files in directories referenced by add_subdirectory() or subdirs(), +treating them as if present but empty. In CMake 2.8.0 and above this +policy determines whether or not the case is an error. The OLD +behavior for this policy is to silently ignore the problem. The NEW +behavior for this policy is to report an error. + +This policy was introduced in CMake version 2.8.0. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0015.rst b/Help/policy/CMP0015.rst new file mode 100644 index 0000000..1b54979 --- /dev/null +++ b/Help/policy/CMP0015.rst @@ -0,0 +1,17 @@ +CMP0015 +------- + +link_directories() treats paths relative to the source dir. + +In CMake 2.8.0 and lower the link_directories() command passed +relative paths unchanged to the linker. In CMake 2.8.1 and above the +link_directories() command prefers to interpret relative paths with +respect to CMAKE_CURRENT_SOURCE_DIR, which is consistent with +include_directories() and other commands. The OLD behavior for this +policy is to use relative paths verbatim in the linker command. The +NEW behavior for this policy is to convert relative paths to absolute +paths by appending the relative path to CMAKE_CURRENT_SOURCE_DIR. + +This policy was introduced in CMake version 2.8.1. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0016.rst b/Help/policy/CMP0016.rst new file mode 100644 index 0000000..743b1a9 --- /dev/null +++ b/Help/policy/CMP0016.rst @@ -0,0 +1,13 @@ +CMP0016 +------- + +target_link_libraries() reports error if its only argument is not a target. + +In CMake 2.8.2 and lower the target_link_libraries() command silently +ignored if it was called with only one argument, and this argument +wasn't a valid target. In CMake 2.8.3 and above it reports an error +in this case. + +This policy was introduced in CMake version 2.8.3. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0017.rst b/Help/policy/CMP0017.rst new file mode 100644 index 0000000..c93e8b2 --- /dev/null +++ b/Help/policy/CMP0017.rst @@ -0,0 +1,19 @@ +CMP0017 +------- + +Prefer files from the CMake module directory when including from there. + +Starting with CMake 2.8.4, if a cmake-module shipped with CMake (i.e. +located in the CMake module directory) calls include() or +find_package(), the files located in the CMake module directory are +preferred over the files in CMAKE_MODULE_PATH. This makes sure that +the modules belonging to CMake always get those files included which +they expect, and against which they were developed and tested. In all +other cases, the files found in CMAKE_MODULE_PATH still take +precedence over the ones in the CMake module directory. The OLD +behaviour is to always prefer files from CMAKE_MODULE_PATH over files +from the CMake modules directory. + +This policy was introduced in CMake version 2.8.4. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0018.rst b/Help/policy/CMP0018.rst new file mode 100644 index 0000000..0f68267 --- /dev/null +++ b/Help/policy/CMP0018.rst @@ -0,0 +1,32 @@ +CMP0018 +------- + +Ignore CMAKE_SHARED_LIBRARY_<Lang>_FLAGS variable. + +CMake 2.8.8 and lower compiled sources in SHARED and MODULE libraries +using the value of the undocumented CMAKE_SHARED_LIBRARY_<Lang>_FLAGS +platform variable. The variable contained platform-specific flags +needed to compile objects for shared libraries. Typically it included +a flag such as -fPIC for position independent code but also included +other flags needed on certain platforms. CMake 2.8.9 and higher +prefer instead to use the POSITION_INDEPENDENT_CODE target property to +determine what targets should be position independent, and new +undocumented platform variables to select flags while ignoring +CMAKE_SHARED_LIBRARY_<Lang>_FLAGS completely. + +The default for either approach produces identical compilation flags, +but if a project modifies CMAKE_SHARED_LIBRARY_<Lang>_FLAGS from its +original value this policy determines which approach to use. + +The OLD behavior for this policy is to ignore the +POSITION_INDEPENDENT_CODE property for all targets and use the +modified value of CMAKE_SHARED_LIBRARY_<Lang>_FLAGS for SHARED and +MODULE libraries. + +The NEW behavior for this policy is to ignore +CMAKE_SHARED_LIBRARY_<Lang>_FLAGS whether it is modified or not and +honor the POSITION_INDEPENDENT_CODE target property. + +This policy was introduced in CMake version 2.8.9. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0019.rst b/Help/policy/CMP0019.rst new file mode 100644 index 0000000..2b37fa1 --- /dev/null +++ b/Help/policy/CMP0019.rst @@ -0,0 +1,20 @@ +CMP0019 +------- + +Do not re-expand variables in include and link information. + +CMake 2.8.10 and lower re-evaluated values given to the +include_directories, link_directories, and link_libraries commands to +expand any leftover variable references at the end of the +configuration step. This was for strict compatibility with VERY early +CMake versions because all variable references are now normally +evaluated during CMake language processing. CMake 2.8.11 and higher +prefer to skip the extra evaluation. + +The OLD behavior for this policy is to re-evaluate the values for +strict compatibility. The NEW behavior for this policy is to leave +the values untouched. + +This policy was introduced in CMake version 2.8.11. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0020.rst b/Help/policy/CMP0020.rst new file mode 100644 index 0000000..ad664b0 --- /dev/null +++ b/Help/policy/CMP0020.rst @@ -0,0 +1,25 @@ +CMP0020 +------- + +Automatically link Qt executables to qtmain target on Windows. + +CMake 2.8.10 and lower required users of Qt to always specify a link +dependency to the qtmain.lib static library manually on Windows. +CMake 2.8.11 gained the ability to evaluate generator expressions +while determining the link dependencies from IMPORTED targets. This +allows CMake itself to automatically link executables which link to Qt +to the qtmain.lib library when using IMPORTED Qt targets. For +applications already linking to qtmain.lib, this should have little +impact. For applications which supply their own alternative WinMain +implementation and for applications which use the QAxServer library, +this automatic linking will need to be disabled as per the +documentation. + +The OLD behavior for this policy is not to link executables to +qtmain.lib automatically when they link to the QtCore IMPORTEDtarget. +The NEW behavior for this policy is to link executables to qtmain.lib +automatically when they link to QtCore IMPORTED target. + +This policy was introduced in CMake version 2.8.11. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0021.rst b/Help/policy/CMP0021.rst new file mode 100644 index 0000000..3f5bd03 --- /dev/null +++ b/Help/policy/CMP0021.rst @@ -0,0 +1,18 @@ +CMP0021 +------- + +Fatal error on relative paths in INCLUDE_DIRECTORIES target property. + +CMake 2.8.10.2 and lower allowed the INCLUDE_DIRECTORIES target +property to contain relative paths. The base path for such relative +entries is not well defined. CMake 2.8.12 issues a FATAL_ERROR if the +INCLUDE_DIRECTORIES property contains a relative path. + +The OLD behavior for this policy is not to warn about relative paths +in the INCLUDE_DIRECTORIES target property. The NEW behavior for this +policy is to issue a FATAL_ERROR if INCLUDE_DIRECTORIES contains a +relative path. + +This policy was introduced in CMake version 2.8.12. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0022.rst b/Help/policy/CMP0022.rst new file mode 100644 index 0000000..78c688a --- /dev/null +++ b/Help/policy/CMP0022.rst @@ -0,0 +1,33 @@ +CMP0022 +------- + +INTERFACE_LINK_LIBRARIES defines the link interface. + +CMake 2.8.11 constructed the 'link interface' of a target from +properties matching (IMPORTED_)?LINK_INTERFACE_LIBRARIES(_<CONFIG>)?. +The modern way to specify config-sensitive content is to use generator +expressions and the IMPORTED_ prefix makes uniform processing of the +link interface with generator expressions impossible. The +INTERFACE_LINK_LIBRARIES target property was introduced as a +replacement in CMake 2.8.12. This new property is named consistently +with the INTERFACE_COMPILE_DEFINITIONS, INTERFACE_INCLUDE_DIRECTORIES +and INTERFACE_COMPILE_OPTIONS properties. For in-build targets, CMake +will use the INTERFACE_LINK_LIBRARIES property as the source of the +link interface only if policy CMP0022 is NEW. When exporting a target +which has this policy set to NEW, only the INTERFACE_LINK_LIBRARIES +property will be processed and generated for the IMPORTED target by +default. A new option to the install(EXPORT) and export commands +allows export of the old-style properties for compatibility with +downstream users of CMake versions older than 2.8.12. The +target_link_libraries command will no longer populate the properties +matching LINK_INTERFACE_LIBRARIES(_<CONFIG>)? if this policy is NEW. + +The OLD behavior for this policy is to ignore the +INTERFACE_LINK_LIBRARIES property for in-build targets. The NEW +behavior for this policy is to use the INTERFACE_LINK_LIBRARIES +property for in-build targets, and ignore the old properties matching +(IMPORTED_)?LINK_INTERFACE_LIBRARIES(_<CONFIG>)?. + +This policy was introduced in CMake version 2.8.12. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0023.rst b/Help/policy/CMP0023.rst new file mode 100644 index 0000000..962b624 --- /dev/null +++ b/Help/policy/CMP0023.rst @@ -0,0 +1,33 @@ +CMP0023 +------- + +Plain and keyword target_link_libraries signatures cannot be mixed. + +CMake 2.8.12 introduced the target_link_libraries signature using the +PUBLIC, PRIVATE, and INTERFACE keywords to generalize the LINK_PUBLIC +and LINK_PRIVATE keywords introduced in CMake 2.8.7. Use of +signatures with any of these keywords sets the link interface of a +target explicitly, even if empty. This produces confusing behavior +when used in combination with the historical behavior of the plain +target_link_libraries signature. For example, consider the code: + +:: + + target_link_libraries(mylib A) + target_link_libraries(mylib PRIVATE B) + +After the first line the link interface has not been set explicitly so +CMake would use the link implementation, A, as the link interface. +However, the second line sets the link interface to empty. In order +to avoid this subtle behavior CMake now prefers to disallow mixing the +plain and keyword signatures of target_link_libraries for a single +target. + +The OLD behavior for this policy is to allow keyword and plain +target_link_libraries signatures to be mixed. The NEW behavior for +this policy is to not to allow mixing of the keyword and plain +signatures. + +This policy was introduced in CMake version 2.8.12. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0024.rst b/Help/policy/CMP0024.rst new file mode 100644 index 0000000..ce0b2e6 --- /dev/null +++ b/Help/policy/CMP0024.rst @@ -0,0 +1,22 @@ +CMP0024 +------- + +Disallow include export result. + +CMake 2.8.12 and lower allowed use of the include() command with the +result of the export() command. This relies on the assumption that +the export() command has an immediate effect at configure-time during +a cmake run. Certain properties of targets are not fully determined +until later at generate-time, such as the link language and complete +list of link libraries. Future refactoring will change the effect of +the export() command to be executed at generate-time. Use ALIAS +targets instead in cases where the goal is to refer to targets by +another name + +The OLD behavior for this policy is to allow including the result of +an export() command. The NEW behavior for this policy is to not to +allow including the result of an export() command. + +This policy was introduced in CMake version 2.8.13. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0025.rst b/Help/policy/CMP0025.rst new file mode 100644 index 0000000..25957e9 --- /dev/null +++ b/Help/policy/CMP0025.rst @@ -0,0 +1,21 @@ +CMP0025 +------- + +Compiler id for Apple Clang is now AppleClang. + +CMake >= 2.8.13 recognize that Apple Clang is a different compiler +than upstream Clang and that they have different version numbers. +CMake now prefers to present this to projects by setting +CMAKE_<LANG>_COMPILER_ID to "AppleClang" instead of "Clang". However, +existing projects may assume the compiler id for Apple Clang is just +"Clang" as it was in CMake < 2.8.13. Therefore this policy determines +for Apple Clang which compiler id to report in +CMAKE_<LANG>_COMPILER_ID after <LANG> is enabled by the project() or +enable_language() command. + +The OLD behavior for this policy is to use compiler id "Clang". The +NEW behavior for this policy is to use compiler id "AppleClang". + +This policy was introduced in CMake version 2.8.13. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. diff --git a/Help/policy/CMP0026.rst b/Help/policy/CMP0026.rst new file mode 100644 index 0000000..585da56 --- /dev/null +++ b/Help/policy/CMP0026.rst @@ -0,0 +1,25 @@ +CMP0026 +------- + +Disallow use of the LOCATION target property. + +CMake 2.8.12 and lower allowed reading the LOCATION target property to +determine the eventual location of build targets. This relies on the +assumption that all necessary information is available at +configure-time to determine the final location and filename of the +target. However, this property is not fully determined until later at +generate-time. At generate time, the $<TARGET_FILE> generator +expression can be used to determine the eventual LOCATION of a target +output. + +Code which reads the LOCATION target property can be ported to use the +$<TARGET_FILE> generator expression together with the file(GENERATE) +subcommand to generate a file containing the target location. + +The OLD behavior for this policy is to allow reading the LOCATION +property from build-targets. The NEW behavior for this policy is to +not to allow reading the LOCATION property from build-targets. + +This policy was introduced in CMake version 2.8.13. CMake version +|release| warns when the policy is not set and uses OLD behavior. Use +the cmake_policy command to set it to OLD or NEW explicitly. |