GitLab

Download http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt and place
it as Licenses/LGPLv2.1.txt in our source tree.  When building cmake-gui,
use option CMake_GUI_DISTRIBUTE_WITH_Qt_LGPL to enable notification
in the "About" dialog of how the distribution of Qt is licensed.
Install the license file as ${CMAKE_ROOT}/Licenses/LGPLv2.1.txt so that
the dialog can display a path to it.

Add maintenance credit to command-line "--version" output and the
cmake-gui "About" dialog.

f0db2e38 Help: Document macro argument caveats in more detail

7cd65c97 Add CMAKE_SYSROOT variable to set --sysroot when cross compiling.
5096967e Allow toolchain files to specify an external toolchain.
76552d59 Add compiler target compile options.
f41ecd1d CMakeDetermineCompilerId: Look for internal file only on host

As CMAKE_ROOT_FIND_PATH can be a list, a new CMAKE_SYSROOT is
introduced, which is never a list.

The contents of this variable is passed to supporting compilers
as --sysroot. It is also accounted for when processing implicit
link directories reported by the compiler, and when generating
RPATH information.

Clang can compile code, but uses the gcc tools for other tasks such
as linking. The -gcc-toolchain option can be used for that, but
generalize so that other compilers can be treated the same.

If such a location is specified, use it as a hint for finding
the binutils executables.

For clang, this allows passing -target <triple> to the compiler, and
for qcc, -V<arch> using toolchain files containing something like

 set(triple arm-linux-gnueabihf)
 set(CMAKE_C_COMPILER "/usr/bin/clang")
 set(CMAKE_C_COMPILER_TARGET ${triple})
 set(CMAKE_CXX_COMPILER "/usr/bin/clang++")
 set(CMAKE_CXX_COMPILER_TARGET ${triple})

or

 set(arch gcc_ntoarmv7le)
 set(CMAKE_C_COMPILER /opt/qnx650/host/linux/x86/usr/bin/qcc)
 set(CMAKE_C_COMPILER_TARGET ${arch})
 set(CMAKE_CXX_COMPILER /opt/qnx650/host/linux/x86/usr/bin/QCC)
 set(CMAKE_CXX_COMPILER_TARGET ${arch})

Both clang and qcc are inherently cross compiler( driver)s.

When cross-compiling with clang, use the CMAKE_${lang}_COMPILER_TARGET
as the _CMAKE_TOOLCHAIN_PREFIX to find the appropriate binutils.

When cross-compiling with QNX qcc, use the CMAKE_${lang}_COMPILER_TARGET
to set the appropriate _CMAKE_TOOLCHAIN_PREFIX.

The find_file this module uses to locate the compiler id source file
must always look on the host and never in CMAKE_FIND_ROOT_PATH, even
when a toolchain file has

 set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

Add NO_CMAKE_FIND_ROOT_PATH to the find_file call to avoid rerooting.

4cce44b6 Help: Document the CMAKE_MAKE_PROGRAM variable in more detail
558c74d0 VS: Switch to internal CMAKE_MAKE_PROGRAM lookup by generators
5229f2df Tests: Do not use an explicit make program for VS generators
72dd738b Tests: Fix MFC test heuristic for empty CMAKE_TEST_MAKEPROGRAM
fd6076d0 Tests: Pass CMAKE_MAKE_PROGRAM instead of --build-makeprogram
68031abf Tests: Configure SubProject-Stage2 test more robustly
003d10c2 Tests: Simplify VSExcludeFromDefaultBuild configuration
e47d934a Tests: Simplify VSProjectInSubdir configuration
e965cb12 Tests: Simplify CTest.BuildCommand.ProjectInSubdir configuration
72bf2552 Tests: Pass --build-options to every test
4d1d7725 ctest: Teach --build-options to allow zero options
96966b5c ctest: Make the --build-makeprogram optional for --build-and-test
91a02114 Simplify some calls to cmGlobalGenerator::Build
123a0608 Teach GenerateBuildCommand to find its own make program
5f5c92b9 VS: Add internal APIs to find MSBuild, devenv/VCExpress, and msdev
4ac75fdf Prefer CMAKE_MAKE_PROGRAM over CMAKE_BUILD_TOOL (#14548)
...

01ecd24f ExternalProject: Format module documentation

3900fcf4 CMP0037: Extend policy to reserved names and custom targets

0f212618 cmake-mode.el: drop reserved keybindings (#14576)

7621ad6e CPack: don't write internal variables to CPackConfig.cmake

3a8f34b9 Makefile: Remove "forbidden" flags only as a whole

Teach add_custom_target to check the policy too.  Extend the policy to
disallow reserved target names that we use for builtin targets like
"all".

Extend the RunCMake.CMP0037 test to cover these cases.

Fix CMAKE_<LANG>_CREATE_SHARED_LIBRARY_FORBIDDEN_FLAGS implementation to
only remove whole flags.  Without this n the Mac we were incorrectly
removing -w from -Wno-write-strings.

Manually revise the .rst format of the documentation.  Use inline
literal quotes appropriately in paragraph text.  Move the :: literal
block openers to the end of the preceding paragraphs.  Convert the
command signature documentation and examples to cmake code-block
directives.

Add notes about macro arguments in the foreach, if, and list commands.
Add a section to the macro command documentation explaining in detail
how macro arguments are not variables.

Explain how it is set for each group of generators.  Also explain
the build-time selection behavior used by Visual Studio generators.

Drop the "Modules/CMakeVS*FindMake.cmake" files.  Override the
cmGlobalGenerator::FindMakeProgram method for VS generators to use their
internal APIs to locate the build tool.  Set the CMAKE_MAKE_PROGRAM as a
normal variable for use by project code, but do not cache it.  This will
allow CMake and CTest to select the proper tool at build time.

Do not pass the CMAKE_MAKE_PROGRAM cache entry to tests when using the
VS generators.  Allow them to pick the correct build tool automatically.

Also disable the MFC test if CMAKE_MAKE_PROGRAM is vcexpress.

Pass the CMAKE_TEST_MAKEPROGRAM, if any, to each test at CMake time in
the CMAKE_MAKE_PROGRAM cache entry.  Pass the CMAKE_TEST_MAKEPROGRAM
into the ExportImport, Fortran, and MacRuntimePath tests so that they
may do the same for the nested project configurations.

Now "ctest --build-and-test" can get the make program from the test
build tree cache, so drop the explicit --build-makeprogram.

Fix the condition that adds the test to check CMAKE_TEST_GENERATOR
rather than the tools used to build CMake.  Drop the test on Ninja
because the generator does not support subproject generation anyway.
Stop using the general build_generator_args and pass the
--build-generator options explicitly.  Also pass --build-makeprogram
explicitly when CMAKE_TEST_MAKEPROGRAM is available because there is no
CMakeCache.txt in the test project subdirectory from which to pick up
the make program.

Create a CTEST_TEST_DEVENV variable that is set to the
CMAKE_MAKE_PROGRAM used for Visual Studio 7, 8, and 9.  It will always
be either "devenv" or "VCExpress", and not "MSBuild".  Add the
VSExcludeFromDefaultBuild test only when this variable is set, and use
its value as the --build-makeprogram value.

More work will be needed later to restore the test on VS 10 and above
when devenv is available, but this is the simplest approach for now.

The test is only enabled on VS 10 and above, where the generators now
select for "ctest --build-and-test" the MSBuild tool by default.
Simplify the test configuration by dropping the --build-makeprogram
option and all the logic needed to compute its value.  The test will
automatically use MSBuild.

Collect all ctest_configure options in a list to configure it into the
test script.  Drop the unused -DCMAKE_MAKE_PROGRAM argument to ctest.

Create a "build_options" variable whose value is passed to every
"ctest --build-and-test" call through the --build-options argument.

The --build-options option consumes all following arguments until either
--build-target or --test-command.  Fix the logic to allow this to be
zero options.

GenerateBuildCommand now knows how to lookup CMAKE_MAKE_PROGRAM or
choose a generator-provided default build tool.  Therefore the
--build-makeprogram can now be optional and simply override the
default selection when provided.

Note that with --build-nocmake we now need to load the cache in order to
make the CMAKE_MAKE_PROGRAM entry available to GenerateBuildCommand.

Code paths that look up CMAKE_MAKE_PROGRAM from the cache only to
pass it to Build, which only passes it to GenerateBuildCommand,
no longer need to do so.  GenerateBuildCommand now knows how to
look up CMAKE_MAKE_PROGRAM in the cache when no explicit value
is given, so simply pass 0 now.

Add a cmGlobalGenerator::SelectMakeProgram method to select a
caller-provided make program, the CMAKE_MAKE_PROGRAM cache entry, or a
generator-provided default.  Call it from all implementations of the
GenerateBuildCommand method with the corresponding generator's default,
if any.

The keybindings added by commit 301e67e3 (cmake-mode.el: add local
keybindings, 2012-09-20) overlap the reserved C-c space:

 http://www.gnu.org/software/emacs/manual/html_node/elisp/Key-Binding-Conventions.html

Revert the commit to drop them.
Reported-by: Paul Smith <paul@mad-scientist.net>
Reviewed-by: Eric NOULARD <eric.noulard@gmail.com>

7eb99406 CTest: added documentation for the "Upload" submission PART

Teach the VS generators to compute the locations of these tools directly
from registry entries.  Add internal APIs to get the locations on demand.

Historically these were both added for the Makefile and Visual Studio
generators, respectively.  Later the VS generators started using the
CMAKE_MAKE_PROGRAM cache entry to find the IDE build tool, and the
CMAKE_BUILD_TOOL was simply set as an alias.

Fix the documentation to explain that CMAKE_MAKE_PROGRAM is the modern
variable and that CMAKE_BUILD_TOOL is the compatibility alias, not the
other way around.  Replace uses of CMAKE_BUILD_TOOL with
CMAKE_MAKE_PROGRAM in CMake-provided modules.  Nothing needs to lookup
CMAKE_BUILD_TOOL in the cache, so simply set it as a normal variable.

Some extra options are for "ctest --build-and-test" directly, and others
are values for "--build-options".  Split these two roles out into two
separate variables and update existing uses.

Drop the -DCMAKE_TEST_MAKEPROGRAM argument because the value is not
used inside the test script.