From 091caafda44f7fe52a94387b2eafcf204ea909d3 Mon Sep 17 00:00:00 2001 From: Vince Harron Date: Tue, 2 Jun 2015 18:37:41 -0700 Subject: Adding binaries for 3.2.3 --- share/cmake-3.2/Help/policy/CMP0000.rst | 30 ++++++ share/cmake-3.2/Help/policy/CMP0001.rst | 19 ++++ share/cmake-3.2/Help/policy/CMP0002.rst | 26 ++++++ share/cmake-3.2/Help/policy/CMP0003.rst | 102 +++++++++++++++++++++ share/cmake-3.2/Help/policy/CMP0004.rst | 23 +++++ share/cmake-3.2/Help/policy/CMP0005.rst | 24 +++++ share/cmake-3.2/Help/policy/CMP0006.rst | 22 +++++ share/cmake-3.2/Help/policy/CMP0007.rst | 15 +++ share/cmake-3.2/Help/policy/CMP0008.rst | 32 +++++++ share/cmake-3.2/Help/policy/CMP0009.rst | 19 ++++ share/cmake-3.2/Help/policy/CMP0010.rst | 18 ++++ share/cmake-3.2/Help/policy/CMP0011.rst | 22 +++++ share/cmake-3.2/Help/policy/CMP0012.rst | 25 +++++ share/cmake-3.2/Help/policy/CMP0013.rst | 19 ++++ share/cmake-3.2/Help/policy/CMP0014.rst | 15 +++ share/cmake-3.2/Help/policy/CMP0015.rst | 17 ++++ share/cmake-3.2/Help/policy/CMP0016.rst | 13 +++ share/cmake-3.2/Help/policy/CMP0017.rst | 19 ++++ share/cmake-3.2/Help/policy/CMP0018.rst | 32 +++++++ share/cmake-3.2/Help/policy/CMP0019.rst | 20 ++++ share/cmake-3.2/Help/policy/CMP0020.rst | 25 +++++ share/cmake-3.2/Help/policy/CMP0021.rst | 18 ++++ share/cmake-3.2/Help/policy/CMP0022.rst | 37 ++++++++ share/cmake-3.2/Help/policy/CMP0023.rst | 33 +++++++ share/cmake-3.2/Help/policy/CMP0024.rst | 22 +++++ share/cmake-3.2/Help/policy/CMP0025.rst | 27 ++++++ share/cmake-3.2/Help/policy/CMP0026.rst | 26 ++++++ share/cmake-3.2/Help/policy/CMP0027.rst | 25 +++++ share/cmake-3.2/Help/policy/CMP0028.rst | 23 +++++ share/cmake-3.2/Help/policy/CMP0029.rst | 10 ++ share/cmake-3.2/Help/policy/CMP0030.rst | 11 +++ share/cmake-3.2/Help/policy/CMP0031.rst | 13 +++ share/cmake-3.2/Help/policy/CMP0032.rst | 13 +++ share/cmake-3.2/Help/policy/CMP0033.rst | 14 +++ share/cmake-3.2/Help/policy/CMP0034.rst | 11 +++ share/cmake-3.2/Help/policy/CMP0035.rst | 10 ++ share/cmake-3.2/Help/policy/CMP0036.rst | 12 +++ share/cmake-3.2/Help/policy/CMP0037.rst | 26 ++++++ share/cmake-3.2/Help/policy/CMP0038.rst | 16 ++++ share/cmake-3.2/Help/policy/CMP0039.rst | 17 ++++ share/cmake-3.2/Help/policy/CMP0040.rst | 16 ++++ share/cmake-3.2/Help/policy/CMP0041.rst | 25 +++++ share/cmake-3.2/Help/policy/CMP0042.rst | 19 ++++ share/cmake-3.2/Help/policy/CMP0043.rst | 45 +++++++++ share/cmake-3.2/Help/policy/CMP0044.rst | 19 ++++ share/cmake-3.2/Help/policy/CMP0045.rst | 17 ++++ share/cmake-3.2/Help/policy/CMP0046.rst | 17 ++++ share/cmake-3.2/Help/policy/CMP0047.rst | 28 ++++++ share/cmake-3.2/Help/policy/CMP0048.rst | 22 +++++ share/cmake-3.2/Help/policy/CMP0049.rst | 23 +++++ share/cmake-3.2/Help/policy/CMP0050.rst | 18 ++++ share/cmake-3.2/Help/policy/CMP0051.rst | 24 +++++ share/cmake-3.2/Help/policy/CMP0052.rst | 24 +++++ share/cmake-3.2/Help/policy/CMP0053.rst | 44 +++++++++ share/cmake-3.2/Help/policy/CMP0054.rst | 46 ++++++++++ share/cmake-3.2/Help/policy/CMP0055.rst | 17 ++++ share/cmake-3.2/Help/policy/CMP0056.rst | 32 +++++++ share/cmake-3.2/Help/policy/DISALLOWED_COMMAND.txt | 9 ++ 58 files changed, 1346 insertions(+) create mode 100644 share/cmake-3.2/Help/policy/CMP0000.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0001.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0002.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0003.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0004.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0005.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0006.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0007.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0008.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0009.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0010.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0011.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0012.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0013.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0014.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0015.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0016.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0017.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0018.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0019.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0020.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0021.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0022.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0023.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0024.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0025.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0026.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0027.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0028.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0029.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0030.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0031.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0032.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0033.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0034.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0035.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0036.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0037.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0038.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0039.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0040.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0041.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0042.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0043.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0044.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0045.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0046.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0047.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0048.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0049.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0050.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0051.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0052.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0053.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0054.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0055.rst create mode 100644 share/cmake-3.2/Help/policy/CMP0056.rst create mode 100644 share/cmake-3.2/Help/policy/DISALLOWED_COMMAND.txt (limited to 'share/cmake-3.2/Help/policy') diff --git a/share/cmake-3.2/Help/policy/CMP0000.rst b/share/cmake-3.2/Help/policy/CMP0000.rst new file mode 100644 index 0000000..9fbf842 --- /dev/null +++ b/share/cmake-3.2/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 .) + +where "." 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/share/cmake-3.2/Help/policy/CMP0001.rst b/share/cmake-3.2/Help/policy/CMP0001.rst new file mode 100644 index 0000000..344f1e2 --- /dev/null +++ b/share/cmake-3.2/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/share/cmake-3.2/Help/policy/CMP0002.rst b/share/cmake-3.2/Help/policy/CMP0002.rst new file mode 100644 index 0000000..2c15bd4 --- /dev/null +++ b/share/cmake-3.2/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/share/cmake-3.2/Help/policy/CMP0003.rst b/share/cmake-3.2/Help/policy/CMP0003.rst new file mode 100644 index 0000000..27b83f8 --- /dev/null +++ b/share/cmake-3.2/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/share/cmake-3.2/Help/policy/CMP0004.rst b/share/cmake-3.2/Help/policy/CMP0004.rst new file mode 100644 index 0000000..80045f5 --- /dev/null +++ b/share/cmake-3.2/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/share/cmake-3.2/Help/policy/CMP0005.rst b/share/cmake-3.2/Help/policy/CMP0005.rst new file mode 100644 index 0000000..c11a9e6 --- /dev/null +++ b/share/cmake-3.2/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/share/cmake-3.2/Help/policy/CMP0006.rst b/share/cmake-3.2/Help/policy/CMP0006.rst new file mode 100644 index 0000000..8d1e5bd --- /dev/null +++ b/share/cmake-3.2/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/share/cmake-3.2/Help/policy/CMP0007.rst b/share/cmake-3.2/Help/policy/CMP0007.rst new file mode 100644 index 0000000..f0d8c16 --- /dev/null +++ b/share/cmake-3.2/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/share/cmake-3.2/Help/policy/CMP0008.rst b/share/cmake-3.2/Help/policy/CMP0008.rst new file mode 100644 index 0000000..b118ece --- /dev/null +++ b/share/cmake-3.2/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/share/cmake-3.2/Help/policy/CMP0009.rst b/share/cmake-3.2/Help/policy/CMP0009.rst new file mode 100644 index 0000000..481af1a --- /dev/null +++ b/share/cmake-3.2/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/share/cmake-3.2/Help/policy/CMP0010.rst b/share/cmake-3.2/Help/policy/CMP0010.rst new file mode 100644 index 0000000..9d2eb76 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0010.rst @@ -0,0 +1,18 @@ +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. + +If :policy:`CMP0053` is set to ``NEW``, this policy has no effect +and is treated as always being ``NEW``. + +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/share/cmake-3.2/Help/policy/CMP0011.rst b/share/cmake-3.2/Help/policy/CMP0011.rst new file mode 100644 index 0000000..0f41fff --- /dev/null +++ b/share/cmake-3.2/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/share/cmake-3.2/Help/policy/CMP0012.rst b/share/cmake-3.2/Help/policy/CMP0012.rst new file mode 100644 index 0000000..7a749bf --- /dev/null +++ b/share/cmake-3.2/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/share/cmake-3.2/Help/policy/CMP0013.rst b/share/cmake-3.2/Help/policy/CMP0013.rst new file mode 100644 index 0000000..e99997b --- /dev/null +++ b/share/cmake-3.2/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/share/cmake-3.2/Help/policy/CMP0014.rst b/share/cmake-3.2/Help/policy/CMP0014.rst new file mode 100644 index 0000000..37178d1 --- /dev/null +++ b/share/cmake-3.2/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/share/cmake-3.2/Help/policy/CMP0015.rst b/share/cmake-3.2/Help/policy/CMP0015.rst new file mode 100644 index 0000000..1b54979 --- /dev/null +++ b/share/cmake-3.2/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/share/cmake-3.2/Help/policy/CMP0016.rst b/share/cmake-3.2/Help/policy/CMP0016.rst new file mode 100644 index 0000000..743b1a9 --- /dev/null +++ b/share/cmake-3.2/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/share/cmake-3.2/Help/policy/CMP0017.rst b/share/cmake-3.2/Help/policy/CMP0017.rst new file mode 100644 index 0000000..f74e6f0 --- /dev/null +++ b/share/cmake-3.2/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 +behavior 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/share/cmake-3.2/Help/policy/CMP0018.rst b/share/cmake-3.2/Help/policy/CMP0018.rst new file mode 100644 index 0000000..0f68267 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0018.rst @@ -0,0 +1,32 @@ +CMP0018 +------- + +Ignore CMAKE_SHARED_LIBRARY__FLAGS variable. + +CMake 2.8.8 and lower compiled sources in SHARED and MODULE libraries +using the value of the undocumented CMAKE_SHARED_LIBRARY__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__FLAGS completely. + +The default for either approach produces identical compilation flags, +but if a project modifies CMAKE_SHARED_LIBRARY__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__FLAGS for SHARED and +MODULE libraries. + +The NEW behavior for this policy is to ignore +CMAKE_SHARED_LIBRARY__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/share/cmake-3.2/Help/policy/CMP0019.rst b/share/cmake-3.2/Help/policy/CMP0019.rst new file mode 100644 index 0000000..2b37fa1 --- /dev/null +++ b/share/cmake-3.2/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/share/cmake-3.2/Help/policy/CMP0020.rst b/share/cmake-3.2/Help/policy/CMP0020.rst new file mode 100644 index 0000000..6767d08 --- /dev/null +++ b/share/cmake-3.2/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 IMPORTED target. +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/share/cmake-3.2/Help/policy/CMP0021.rst b/share/cmake-3.2/Help/policy/CMP0021.rst new file mode 100644 index 0000000..3f5bd03 --- /dev/null +++ b/share/cmake-3.2/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/share/cmake-3.2/Help/policy/CMP0022.rst b/share/cmake-3.2/Help/policy/CMP0022.rst new file mode 100644 index 0000000..22c7c4f --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0022.rst @@ -0,0 +1,37 @@ +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(_)?``. +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(_)? if this policy is NEW. + +Warning-free future-compatible code which works with CMake 2.8.7 onwards +can be written by using the ``LINK_PRIVATE`` and ``LINK_PUBLIC`` keywords +of :command:`target_link_libraries`. + +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(_)?``. + +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/share/cmake-3.2/Help/policy/CMP0023.rst b/share/cmake-3.2/Help/policy/CMP0023.rst new file mode 100644 index 0000000..962b624 --- /dev/null +++ b/share/cmake-3.2/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/share/cmake-3.2/Help/policy/CMP0024.rst b/share/cmake-3.2/Help/policy/CMP0024.rst new file mode 100644 index 0000000..ee53d5f --- /dev/null +++ b/share/cmake-3.2/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 not to +allow including the result of an export() command. + +This policy was introduced in CMake version 3.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/share/cmake-3.2/Help/policy/CMP0025.rst b/share/cmake-3.2/Help/policy/CMP0025.rst new file mode 100644 index 0000000..8d19edf --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0025.rst @@ -0,0 +1,27 @@ +CMP0025 +------- + +Compiler id for Apple Clang is now ``AppleClang``. + +CMake 3.0 and above 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 the +:variable:`CMAKE__COMPILER_ID` variable to ``AppleClang`` instead +of ``Clang``. However, existing projects may assume the compiler id for +Apple Clang is just ``Clang`` as it was in CMake versions prior to 3.0. +Therefore this policy determines for Apple Clang which compiler id to +report in the :variable:`CMAKE__COMPILER_ID` variable after +language ```` is enabled by the :command:`project` or +:command:`enable_language` command. The policy must be set prior +to the invocation of either 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 3.0. Use the +:command:`cmake_policy` command to set this policy to OLD or NEW explicitly. +Unlike most policies, CMake version |release| does *not* warn +by default when this policy is not set and simply uses OLD behavior. +See documentation of the +:variable:`CMAKE_POLICY_WARNING_CMP0025 >` +variable to control the warning. diff --git a/share/cmake-3.2/Help/policy/CMP0026.rst b/share/cmake-3.2/Help/policy/CMP0026.rst new file mode 100644 index 0000000..177b655 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0026.rst @@ -0,0 +1,26 @@ +CMP0026 +------- + +Disallow use of the LOCATION target property. + +CMake 2.8.12 and lower allowed reading the LOCATION target +property (and configuration-specific variants) 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 $ 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 +$ 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 +properties from build-targets. The NEW behavior for this policy is to +not to allow reading the LOCATION properties from build-targets. + +This policy was introduced in CMake version 3.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/share/cmake-3.2/Help/policy/CMP0027.rst b/share/cmake-3.2/Help/policy/CMP0027.rst new file mode 100644 index 0000000..bedaffe --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0027.rst @@ -0,0 +1,25 @@ +CMP0027 +------- + +Conditionally linked imported targets with missing include directories. + +CMake 2.8.11 introduced introduced the concept of +INTERFACE_INCLUDE_DIRECTORIES, and a check at cmake time that the +entries in the INTERFACE_INCLUDE_DIRECTORIES of an IMPORTED target +actually exist. CMake 2.8.11 also introduced generator expression +support in the target_link_libraries command. However, if an imported +target is linked as a result of a generator expression evaluation, the +entries in the INTERFACE_INCLUDE_DIRECTORIES of that target were not +checked for existence as they should be. + +The OLD behavior of this policy is to report a warning if an entry in +the INTERFACE_INCLUDE_DIRECTORIES of a generator-expression +conditionally linked IMPORTED target does not exist. + +The NEW behavior of this policy is to report an error if an entry in +the INTERFACE_INCLUDE_DIRECTORIES of a generator-expression +conditionally linked IMPORTED target does not exist. + +This policy was introduced in CMake version 3.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/share/cmake-3.2/Help/policy/CMP0028.rst b/share/cmake-3.2/Help/policy/CMP0028.rst new file mode 100644 index 0000000..24889ec --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0028.rst @@ -0,0 +1,23 @@ +CMP0028 +------- + +Double colon in target name means ALIAS or IMPORTED target. + +CMake 2.8.12 and lower allowed the use of targets and files with double +colons in target_link_libraries, with some buildsystem generators. + +The use of double-colons is a common pattern used to namespace IMPORTED +targets and ALIAS targets. When computing the link dependencies of a target, +the name of each dependency could either be a target, or a file on disk. +Previously, if a target was not found with a matching name, the name was +considered to refer to a file on disk. This can lead to confusing error +messages if there is a typo in what should be a target name. + +The OLD behavior for this policy is to search for targets, then files on disk, +even if the search term contains double-colons. The NEW behavior for this +policy is to issue a FATAL_ERROR if a link dependency contains +double-colons but is not an IMPORTED target or an ALIAS target. + +This policy was introduced in CMake version 3.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/share/cmake-3.2/Help/policy/CMP0029.rst b/share/cmake-3.2/Help/policy/CMP0029.rst new file mode 100644 index 0000000..8f58a12 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0029.rst @@ -0,0 +1,10 @@ +CMP0029 +------- + +The :command:`subdir_depends` command should not be called. + +The implementation of this command has been empty since December 2001 +but was kept in CMake for compatibility for a long time. + +.. |disallowed_version| replace:: 3.0 +.. include:: DISALLOWED_COMMAND.txt diff --git a/share/cmake-3.2/Help/policy/CMP0030.rst b/share/cmake-3.2/Help/policy/CMP0030.rst new file mode 100644 index 0000000..9e31b38 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0030.rst @@ -0,0 +1,11 @@ +CMP0030 +------- + +The :command:`use_mangled_mesa` command should not be called. + +This command was created in September 2001 to support VTK before +modern CMake language and custom command capabilities. VTK has +not used it in years. + +.. |disallowed_version| replace:: 3.0 +.. include:: DISALLOWED_COMMAND.txt diff --git a/share/cmake-3.2/Help/policy/CMP0031.rst b/share/cmake-3.2/Help/policy/CMP0031.rst new file mode 100644 index 0000000..6b89558 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0031.rst @@ -0,0 +1,13 @@ +CMP0031 +------- + +The :command:`load_command` command should not be called. + +This command was added in August 2002 to allow projects to add +arbitrary commands implemented in C or C++. However, it does +not work when the toolchain in use does not match the ABI of +the CMake process. It has been mostly superseded by the +:command:`macro` and :command:`function` commands. + +.. |disallowed_version| replace:: 3.0 +.. include:: DISALLOWED_COMMAND.txt diff --git a/share/cmake-3.2/Help/policy/CMP0032.rst b/share/cmake-3.2/Help/policy/CMP0032.rst new file mode 100644 index 0000000..f394a06 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0032.rst @@ -0,0 +1,13 @@ +CMP0032 +------- + +The :command:`output_required_files` command should not be called. + +This command was added in June 2001 to expose the then-current CMake +implicit dependency scanner. CMake's real implicit dependency scanner +has evolved since then but is not exposed through this command. The +scanning capabilities of this command are very limited and this +functionality is better achieved through dedicated outside tools. + +.. |disallowed_version| replace:: 3.0 +.. include:: DISALLOWED_COMMAND.txt diff --git a/share/cmake-3.2/Help/policy/CMP0033.rst b/share/cmake-3.2/Help/policy/CMP0033.rst new file mode 100644 index 0000000..b420065 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0033.rst @@ -0,0 +1,14 @@ +CMP0033 +------- + +The :command:`export_library_dependencies` command should not be called. + +This command was added in January 2003 to export ``_LIB_DEPENDS`` +internal CMake cache entries to a file for installation with a project. +This was used at the time to allow transitive link dependencies to +work for applications outside of the original build tree of a project. +The functionality has been superseded by the :command:`export` and +:command:`install(EXPORT)` commands. + +.. |disallowed_version| replace:: 3.0 +.. include:: DISALLOWED_COMMAND.txt diff --git a/share/cmake-3.2/Help/policy/CMP0034.rst b/share/cmake-3.2/Help/policy/CMP0034.rst new file mode 100644 index 0000000..2133997 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0034.rst @@ -0,0 +1,11 @@ +CMP0034 +------- + +The :command:`utility_source` command should not be called. + +This command was introduced in March 2001 to help build executables used to +generate other files. This approach has long been replaced by +:command:`add_executable` combined with :command:`add_custom_command`. + +.. |disallowed_version| replace:: 3.0 +.. include:: DISALLOWED_COMMAND.txt diff --git a/share/cmake-3.2/Help/policy/CMP0035.rst b/share/cmake-3.2/Help/policy/CMP0035.rst new file mode 100644 index 0000000..7335b22 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0035.rst @@ -0,0 +1,10 @@ +CMP0035 +------- + +The :command:`variable_requires` command should not be called. + +This command was introduced in November 2001 to perform some conditional +logic. It has long been replaced by the :command:`if` command. + +.. |disallowed_version| replace:: 3.0 +.. include:: DISALLOWED_COMMAND.txt diff --git a/share/cmake-3.2/Help/policy/CMP0036.rst b/share/cmake-3.2/Help/policy/CMP0036.rst new file mode 100644 index 0000000..817f156 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0036.rst @@ -0,0 +1,12 @@ +CMP0036 +------- + +The :command:`build_name` command should not be called. + +This command was added in May 2001 to compute a name for the current +operating system and compiler combination. The command has long been +documented as discouraged and replaced by the :variable:`CMAKE_SYSTEM` +and :variable:`CMAKE__COMPILER` variables. + +.. |disallowed_version| replace:: 3.0 +.. include:: DISALLOWED_COMMAND.txt diff --git a/share/cmake-3.2/Help/policy/CMP0037.rst b/share/cmake-3.2/Help/policy/CMP0037.rst new file mode 100644 index 0000000..4d485bf --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0037.rst @@ -0,0 +1,26 @@ +CMP0037 +------- + +Target names should not be reserved and should match a validity pattern. + +CMake 2.8.12 and lower allowed creating targets using :command:`add_library`, +:command:`add_executable` and :command:`add_custom_target` with unrestricted +choice for the target name. Newer cmake features such +as :manual:`cmake-generator-expressions(7)` and some +diagnostics expect target names to match a restricted pattern. + +Target names may contain upper and lower case letters, numbers, the underscore +character (_), dot(.), plus(+) and minus(-). As a special case, ALIAS +targets and IMPORTED targets may contain two consequtive colons. + +Target names reserved by one or more CMake generators are not allowed. +Among others these include "all", "help" and "test". + +The OLD behavior for this policy is to allow creating targets with +reserved names or which do not match the validity pattern. +The NEW behavior for this policy is to report an error +if an add_* command is used with an invalid target name. + +This policy was introduced in CMake version 3.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/share/cmake-3.2/Help/policy/CMP0038.rst b/share/cmake-3.2/Help/policy/CMP0038.rst new file mode 100644 index 0000000..df5af6a --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0038.rst @@ -0,0 +1,16 @@ +CMP0038 +------- + +Targets may not link directly to themselves. + +CMake 2.8.12 and lower allowed a build target to link to itself directly with +a :command:`target_link_libraries` call. This is an indicator of a bug in +user code. + +The OLD behavior for this policy is to ignore targets which list themselves +in their own link implementation. The NEW behavior for this policy is to +report an error if a target attempts to link to itself. + +This policy was introduced in CMake version 3.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/share/cmake-3.2/Help/policy/CMP0039.rst b/share/cmake-3.2/Help/policy/CMP0039.rst new file mode 100644 index 0000000..58ccc41 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0039.rst @@ -0,0 +1,17 @@ +CMP0039 +------- + +Utility targets may not have link dependencies. + +CMake 2.8.12 and lower allowed using utility targets in the left hand side +position of the :command:`target_link_libraries` command. This is an indicator +of a bug in user code. + +The OLD behavior for this policy is to ignore attempts to set the link +libraries of utility targets. The NEW behavior for this policy is to +report an error if an attempt is made to set the link libraries of a +utility target. + +This policy was introduced in CMake version 3.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/share/cmake-3.2/Help/policy/CMP0040.rst b/share/cmake-3.2/Help/policy/CMP0040.rst new file mode 100644 index 0000000..77a3c81 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0040.rst @@ -0,0 +1,16 @@ +CMP0040 +------- + +The target in the TARGET signature of add_custom_command() must exist. + +CMake 2.8.12 and lower silently ignored a custom command created with +the TARGET signature of :command:`add_custom_command` +if the target is unknown. + +The OLD behavior for this policy is to ignore custom commands +for unknown targets. The NEW behavior for this policy is to report an error +if the target referenced in :command:`add_custom_command` is unknown. + +This policy was introduced in CMake version 3.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/share/cmake-3.2/Help/policy/CMP0041.rst b/share/cmake-3.2/Help/policy/CMP0041.rst new file mode 100644 index 0000000..5a47de0 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0041.rst @@ -0,0 +1,25 @@ +CMP0041 +------- + +Error on relative include with generator expression. + +Diagnostics in CMake 2.8.12 and lower silently ignored an entry in the +:prop_tgt:`INTERFACE_INCLUDE_DIRECTORIES` of a target if it contained a generator +expression at any position. + +The path entries in that target property should not be relative. High-level +API should ensure that by adding either a source directory or a install +directory prefix, as appropriate. + +As an additional diagnostic, the :prop_tgt:`INTERFACE_INCLUDE_DIRECTORIES` generated +on an :prop_tgt:`IMPORTED` target for the install location should not contain +paths in the source directory or the build directory. + +The OLD behavior for this policy is to ignore relative path entries if they +contain a generator expression. The NEW behavior for this policy is to report +an error if a generator expression appears in another location and the path is +relative. + +This policy was introduced in CMake version 3.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/share/cmake-3.2/Help/policy/CMP0042.rst b/share/cmake-3.2/Help/policy/CMP0042.rst new file mode 100644 index 0000000..fce870c --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0042.rst @@ -0,0 +1,19 @@ +CMP0042 +------- + +:prop_tgt:`MACOSX_RPATH` is enabled by default. + +CMake 2.8.12 and newer has support for using ``@rpath`` in a target's install +name. This was enabled by setting the target property +:prop_tgt:`MACOSX_RPATH`. The ``@rpath`` in an install name is a more +flexible and powerful mechanism than ``@executable_path`` or ``@loader_path`` +for locating shared libraries. + +CMake 3.0 and later prefer this property to be ON by default. Projects +wanting ``@rpath`` in a target's install name may remove any setting of +the :prop_tgt:`INSTALL_NAME_DIR` and :variable:`CMAKE_INSTALL_NAME_DIR` +variables. + +This policy was introduced in CMake version 3.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/share/cmake-3.2/Help/policy/CMP0043.rst b/share/cmake-3.2/Help/policy/CMP0043.rst new file mode 100644 index 0000000..629e502 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0043.rst @@ -0,0 +1,45 @@ +CMP0043 +------- + +Ignore COMPILE_DEFINITIONS_ properties + +CMake 2.8.12 and lower allowed setting the +:prop_tgt:`COMPILE_DEFINITIONS_` target property and +:prop_dir:`COMPILE_DEFINITIONS_` directory property to apply +configuration-specific compile definitions. + +Since CMake 2.8.10, the :prop_tgt:`COMPILE_DEFINITIONS` property has supported +:manual:`generator expressions ` for setting +configuration-dependent content. The continued existence of the suffixed +variables is redundant, and causes a maintenance burden. Population of the +:prop_tgt:`COMPILE_DEFINITIONS_DEBUG >` property +may be replaced with a population of :prop_tgt:`COMPILE_DEFINITIONS` directly +or via :command:`target_compile_definitions`: + +.. code-block:: cmake + + # Old Interfaces: + set_property(TARGET tgt APPEND PROPERTY + COMPILE_DEFINITIONS_DEBUG DEBUG_MODE + ) + set_property(DIRECTORY APPEND PROPERTY + COMPILE_DEFINITIONS_DEBUG DIR_DEBUG_MODE + ) + + # New Interfaces: + set_property(TARGET tgt APPEND PROPERTY + COMPILE_DEFINITIONS $<$:DEBUG_MODE> + ) + target_compile_definitions(tgt PRIVATE $<$:DEBUG_MODE>) + set_property(DIRECTORY APPEND PROPERTY + COMPILE_DEFINITIONS $<$:DIR_DEBUG_MODE> + ) + +The OLD behavior for this policy is to consume the content of the suffixed +:prop_tgt:`COMPILE_DEFINITIONS_` target property when generating the +compilation command. The NEW behavior for this policy is to ignore the content +of the :prop_tgt:`COMPILE_DEFINITIONS_` target property . + +This policy was introduced in CMake version 3.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/share/cmake-3.2/Help/policy/CMP0044.rst b/share/cmake-3.2/Help/policy/CMP0044.rst new file mode 100644 index 0000000..4a3e215 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0044.rst @@ -0,0 +1,19 @@ +CMP0044 +------- + +Case sensitive ``_COMPILER_ID`` generator expressions + +CMake 2.8.12 introduced the ``_COMPILER_ID`` +:manual:`generator expressions ` to allow +comparison of the :variable:`CMAKE__COMPILER_ID` with a test value. The +possible valid values are lowercase, but the comparison with the test value +was performed case-insensitively. + +The OLD behavior for this policy is to perform a case-insensitive comparison +with the value in the ``_COMPILER_ID`` expression. The NEW behavior +for this policy is to perform a case-sensitive comparison with the value in +the ``_COMPILER_ID`` expression. + +This policy was introduced in CMake version 3.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/share/cmake-3.2/Help/policy/CMP0045.rst b/share/cmake-3.2/Help/policy/CMP0045.rst new file mode 100644 index 0000000..58c422f --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0045.rst @@ -0,0 +1,17 @@ +CMP0045 +------- + +Error on non-existent target in get_target_property. + +In CMake 2.8.12 and lower, the :command:`get_target_property` command accepted +a non-existent target argument without issuing any error or warning. The +result variable is set to a ``-NOTFOUND`` value. + +The OLD behavior for this policy is to issue no warning and set the result +variable to a ``-NOTFOUND`` value. The NEW behavior +for this policy is to issue a ``FATAL_ERROR`` if the command is called with a +non-existent target. + +This policy was introduced in CMake version 3.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/share/cmake-3.2/Help/policy/CMP0046.rst b/share/cmake-3.2/Help/policy/CMP0046.rst new file mode 100644 index 0000000..1a3bc65 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0046.rst @@ -0,0 +1,17 @@ +CMP0046 +------- + +Error on non-existent dependency in add_dependencies. + +CMake 2.8.12 and lower silently ignored non-existent dependencies +listed in the :command:`add_dependencies` command. + +The OLD behavior for this policy is to silently ignore non-existent +dependencies. The NEW behavior for this policy is to report an error +if non-existent dependencies are listed in the :command:`add_dependencies` +command. + +This policy was introduced in CMake version 3.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/share/cmake-3.2/Help/policy/CMP0047.rst b/share/cmake-3.2/Help/policy/CMP0047.rst new file mode 100644 index 0000000..26ae439 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0047.rst @@ -0,0 +1,28 @@ +CMP0047 +------- + +Use ``QCC`` compiler id for the qcc drivers on QNX. + +CMake 3.0 and above recognize that the QNX qcc compiler driver is +different from the GNU compiler. +CMake now prefers to present this to projects by setting the +:variable:`CMAKE__COMPILER_ID` variable to ``QCC`` instead +of ``GNU``. However, existing projects may assume the compiler id for +QNX qcc is just ``GNU`` as it was in CMake versions prior to 3.0. +Therefore this policy determines for QNX qcc which compiler id to +report in the :variable:`CMAKE__COMPILER_ID` variable after +language ```` is enabled by the :command:`project` or +:command:`enable_language` command. The policy must be set prior +to the invocation of either command. + +The OLD behavior for this policy is to use the ``GNU`` compiler id +for the qcc and QCC compiler drivers. The NEW behavior for this policy +is to use the ``QCC`` compiler id for those drivers. + +This policy was introduced in CMake version 3.0. Use the +:command:`cmake_policy` command to set this policy to OLD or NEW explicitly. +Unlike most policies, CMake version |release| does *not* warn +by default when this policy is not set and simply uses OLD behavior. +See documentation of the +:variable:`CMAKE_POLICY_WARNING_CMP0047 >` +variable to control the warning. diff --git a/share/cmake-3.2/Help/policy/CMP0048.rst b/share/cmake-3.2/Help/policy/CMP0048.rst new file mode 100644 index 0000000..a54205e --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0048.rst @@ -0,0 +1,22 @@ +CMP0048 +------- + +The :command:`project` command manages VERSION variables. + +CMake version 3.0 introduced the ``VERSION`` option of the :command:`project` +command to specify a project version as well as the name. In order to keep +:variable:`PROJECT_VERSION` and related variables consistent with variable +:variable:`PROJECT_NAME` it is necessary to set the VERSION variables +to the empty string when no ``VERSION`` is given to :command:`project`. +However, this can change behavior for existing projects that set VERSION +variables themselves since :command:`project` may now clear them. +This policy controls the behavior for compatibility with such projects. + +The OLD behavior for this policy is to leave VERSION variables untouched. +The NEW behavior for this policy is to set VERSION as documented by the +:command:`project` command. + +This policy was introduced in CMake version 3.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/share/cmake-3.2/Help/policy/CMP0049.rst b/share/cmake-3.2/Help/policy/CMP0049.rst new file mode 100644 index 0000000..5c8d4a8 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0049.rst @@ -0,0 +1,23 @@ +CMP0049 +------- + +Do not expand variables in target source entries. + +CMake 2.8.12 and lower performed and extra layer of variable expansion +when evaluating source file names: + +.. code-block:: cmake + + set(a_source foo.c) + add_executable(foo \${a_source}) + +This was undocumented behavior. + +The OLD behavior for this policy is to expand such variables when processing +the target sources. The NEW behavior for this policy is to issue an error +if such variables need to be expanded. + +This policy was introduced in CMake version 3.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/share/cmake-3.2/Help/policy/CMP0050.rst b/share/cmake-3.2/Help/policy/CMP0050.rst new file mode 100644 index 0000000..76ae0aa --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0050.rst @@ -0,0 +1,18 @@ +CMP0050 +------- + +Disallow add_custom_command SOURCE signatures. + +CMake 2.8.12 and lower allowed a signature for :command:`add_custom_command` +which specified an input to a command. This was undocumented behavior. +Modern use of CMake associates custom commands with their output, rather +than their input. + +The OLD behavior for this policy is to allow the use of +:command:`add_custom_command` SOURCE signatures. The NEW behavior for this +policy is to issue an error if such a signature is used. + +This policy was introduced in CMake version 3.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/share/cmake-3.2/Help/policy/CMP0051.rst b/share/cmake-3.2/Help/policy/CMP0051.rst new file mode 100644 index 0000000..1b56cb0 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0051.rst @@ -0,0 +1,24 @@ +CMP0051 +------- + +List TARGET_OBJECTS in SOURCES target property. + +CMake 3.0 and lower did not include the ``TARGET_OBJECTS`` +:manual:`generator expression ` when +returning the :prop_tgt:`SOURCES` target property. + +Configure-time CMake code is not able to handle generator expressions. If +using the :prop_tgt:`SOURCES` target property at configure time, it may be +necessary to first remove generator expressions using the +:command:`string(GENEX_STRIP)` command. Generate-time CMake code such as +:command:`file(GENERATE)` can handle the content without stripping. + +The ``OLD`` behavior for this policy is to omit ``TARGET_OBJECTS`` +expressions from the :prop_tgt:`SOURCES` target property. The ``NEW`` +behavior for this policy is to include ``TARGET_OBJECTS`` expressions +in the output. + +This policy was introduced in CMake version 3.1. +CMake version |release| warns when the policy is not set and uses +``OLD`` behavior. Use the :command:`cmake_policy` command to set it +to ``OLD`` or ``NEW`` explicitly. diff --git a/share/cmake-3.2/Help/policy/CMP0052.rst b/share/cmake-3.2/Help/policy/CMP0052.rst new file mode 100644 index 0000000..48cfc9c --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0052.rst @@ -0,0 +1,24 @@ +CMP0052 +------- + +Reject source and build dirs in installed INTERFACE_INCLUDE_DIRECTORIES. + +CMake 3.0 and lower allowed subdirectories of the source directory or build +directory to be in the :prop_tgt:`INTERFACE_INCLUDE_DIRECTORIES` of +installed and exported targets, if the directory was also a subdirectory of +the installation prefix. This makes the installation depend on the +existence of the source dir or binary dir, and the installation will be +broken if either are removed after installation. + +See :ref:`Include Directories and Usage Requirements` for more on +specifying include directories for targets. + +The OLD behavior for this policy is to export the content of the +:prop_tgt:`INTERFACE_INCLUDE_DIRECTORIES` with the source or binary +directory. The NEW behavior for this +policy is to issue an error if such a directory is used. + +This policy was introduced in CMake version 3.1. +CMake version |release| warns when the policy is not set and uses +``OLD`` behavior. Use the :command:`cmake_policy` command to set it +to ``OLD`` or ``NEW`` explicitly. diff --git a/share/cmake-3.2/Help/policy/CMP0053.rst b/share/cmake-3.2/Help/policy/CMP0053.rst new file mode 100644 index 0000000..bb0ff8b --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0053.rst @@ -0,0 +1,44 @@ +CMP0053 +------- + +Simplify variable reference and escape sequence evaluation. + +CMake 3.1 introduced a much faster implementation of evaluation of the +:ref:`Variable References` and :ref:`Escape Sequences` documented in the +:manual:`cmake-language(7)` manual. While the behavior is identical +to the legacy implementation in most cases, some corner cases were +cleaned up to simplify the behavior. Specifically: + +* Expansion of ``@VAR@`` reference syntax defined by the + :command:`configure_file` and :command:`string(CONFIGURE)` + commands is no longer performed in other contexts. + +* Literal ``${VAR}`` reference syntax may contain only + alphanumeric characters (``A-Z``, ``a-z``, ``0-9``) and + the characters ``_``, ``.``, ``/``, ``-``, and ``+``. + Variables with other characters in their name may still + be referenced indirectly, e.g. + + .. code-block:: cmake + + set(varname "otherwise & disallowed $ characters") + message("${${varname}}") + +* The setting of policy :policy:`CMP0010` is not considered, + so improper variable reference syntax is always an error. + +* More characters are allowed to be escaped in variable names. + Previously, only ``()#" \@^`` were valid characters to + escape. Now any non-alphanumeric, non-semicolon, non-NUL + character may be escaped following the ``escape_identity`` + production in the :ref:`Escape Sequences` section of the + :manual:`cmake-language(7)` manual. + +The ``OLD`` behavior for this policy is to honor the legacy behavior for +variable references and escape sequences. The ``NEW`` behavior is to +use the simpler variable expansion and escape sequence evaluation rules. + +This policy was introduced in CMake version 3.1. +CMake version |release| warns when the policy is not set and uses +``OLD`` behavior. Use the :command:`cmake_policy` command to set +it to ``OLD`` or ``NEW`` explicitly. diff --git a/share/cmake-3.2/Help/policy/CMP0054.rst b/share/cmake-3.2/Help/policy/CMP0054.rst new file mode 100644 index 0000000..39f0c40 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0054.rst @@ -0,0 +1,46 @@ +CMP0054 +------- + +Only interpret :command:`if` arguments as variables or keywords when unquoted. + +CMake 3.1 and above no longer implicitly dereference variables or +interpret keywords in an :command:`if` command argument when +it is a :ref:`Quoted Argument` or a :ref:`Bracket Argument`. + +The ``OLD`` behavior for this policy is to dereference variables and +interpret keywords even if they are quoted or bracketed. +The ``NEW`` behavior is to not dereference variables or interpret keywords +that have been quoted or bracketed. + +Given the following partial example: + +:: + + set(MONKEY 1) + set(ANIMAL MONKEY) + + if("${ANIMAL}" STREQUAL "MONKEY") + +After explicit expansion of variables this gives: + +:: + + if("MONKEY" STREQUAL "MONKEY") + +With the policy set to ``OLD`` implicit expansion reduces this semantically to: + +:: + + if("1" STREQUAL "1") + +With the policy set to ``NEW`` the quoted arguments will not be +further dereferenced: + +:: + + if("MONKEY" STREQUAL "MONKEY") + +This policy was introduced in CMake version 3.1. +CMake version |release| warns when the policy is not set and uses +``OLD`` behavior. Use the :command:`cmake_policy` command to set +it to ``OLD`` or ``NEW`` explicitly. diff --git a/share/cmake-3.2/Help/policy/CMP0055.rst b/share/cmake-3.2/Help/policy/CMP0055.rst new file mode 100644 index 0000000..fe7ab6f --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0055.rst @@ -0,0 +1,17 @@ +CMP0055 +------- + +Strict checking for the :command:`break` command. + +CMake 3.1 and lower allowed calls to the :command:`break` command +outside of a loop context and also ignored any given arguments. +This was undefined behavior. + +The OLD behavior for this policy is to allow :command:`break` to be placed +outside of loop contexts and ignores any arguments. The NEW behavior for this +policy is to issue an error if a misplaced break or any arguments are found. + +This policy was introduced in CMake version 3.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/share/cmake-3.2/Help/policy/CMP0056.rst b/share/cmake-3.2/Help/policy/CMP0056.rst new file mode 100644 index 0000000..3c75ff4 --- /dev/null +++ b/share/cmake-3.2/Help/policy/CMP0056.rst @@ -0,0 +1,32 @@ +CMP0056 +------- + +Honor link flags in :command:`try_compile` source-file signature. + +The :command:`try_compile` command source-file signature generates a +``CMakeLists.txt`` file to build the source file into an executable. +In order to compile the source the same way as it might be compiled +by the calling project, the generated project sets the value of the +:variable:`CMAKE__FLAGS` variable to that in the calling project. +The value of the :variable:`CMAKE_EXE_LINKER_FLAGS` variable may be +needed in some cases too, but CMake 3.1 and lower did not set it in +the generated project. CMake 3.2 and above prefer to set it so that +linker flags are honored as well as compiler flags. This policy +provides compatibility with the pre-3.2 behavior. + +The OLD behavior for this policy is to not set the value of the +:variable:`CMAKE_EXE_LINKER_FLAGS` variable in the generated test +project. The NEW behavior for this policy is to set the value of +the :variable:`CMAKE_EXE_LINKER_FLAGS` variable in the test project +to the same as it is in the calling project. + +If the project code does not set the policy explicitly, users may +set it on the command line by defining the +:variable:`CMAKE_POLICY_DEFAULT_CMP0056 >` +variable in the cache. + +This policy was introduced in CMake version 3.2. Unlike most policies, +CMake version |release| does *not* warn by default when this policy +is not set and simply uses OLD behavior. See documentation of the +:variable:`CMAKE_POLICY_WARNING_CMP0056 >` +variable to control the warning. diff --git a/share/cmake-3.2/Help/policy/DISALLOWED_COMMAND.txt b/share/cmake-3.2/Help/policy/DISALLOWED_COMMAND.txt new file mode 100644 index 0000000..36280d2 --- /dev/null +++ b/share/cmake-3.2/Help/policy/DISALLOWED_COMMAND.txt @@ -0,0 +1,9 @@ +CMake >= |disallowed_version| prefer that this command never be called. +The OLD behavior for this policy is to allow the command to be called. +The NEW behavior for this policy is to issue a FATAL_ERROR when the +command is called. + +This policy was introduced in CMake version |disallowed_version|. +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. -- cgit v1.2.3