Internally cmTarget was passing the target type in several name
computation signatures to support computation of both shared and static
library names for one target. We no longer need to compute both names,
so this change simplifies the internals by using the GetType method and
dropping the type from method signatures.
This property was left from before CMake always linked using full path
library names for targets it builds. In order to safely link with
"-lfoo" we needed to avoid having both shared and static libraries in
the build tree for targets that switch on BUILD_SHARED_LIBS. This meant
cleaning both shared and static names before creating the library, which
led to the creation of CLEAN_DIRECT_OUTPUT to disable the behavior.
Now that we always link with a full path we do not need to clean old
library names left from an alternate setting of BUILD_SHARED_LIBS. This
change removes the CLEAN_DIRECT_OUTPUT property and instead uses its
behavior always. It removes some complexity from cmTarget internally.
This creates target properties ARCHIVE_OUTPUT_NAME, LIBRARY_OUTPUT_NAME,
and RUNTIME_OUTPUT_NAME, and per-configuration equivalent properties
ARCHIVE_OUTPUT_NAME_<CONFIG>, LIBRARY_OUTPUT_NAME_<CONFIG>, and
RUNTIME_OUTPUT_NAME_<CONFIG>. They allow specification of target output
file names on a per-type, per-configuration basis. For example, a .dll
and its .lib import library may have different base names.
For consistency and to avoid ambiguity, the old <CONFIG>_OUTPUT_NAME
property is now also available as OUTPUT_NAME_<CONFIG>.
See issue #8920.
This creates method cmTarget::GetOutputTargetType to compute the output
file type 'ARCHIVE', 'LIBRARY', or 'RUNTIME' from the platform and
target type. It factors out logic from the target output directory
computation code for later re-use.
When CTest runs 'cvs log' to get revision information for updated files,
we were passing '-d<now'. The option seems useless since revisions
cannot be created in the future, and can lose revisions if the client
machine clock is behind the server.
Nested classes have no special access to other members of their
enclosing class. In cmFileCopier the nested class MatchRule must use
MatchProperties, so we grant friendship to it.
This gives cmFileCopier a virtual destructor since it has virtual
methods. While we never actually delete through a base pointer (or
dynamically at all), the compiler doesn't know and warns anyway.
The file(INSTALL) command has long been undocumented and used only to
implement install() scripts. We now document it and provide a similar
file(COPY) signature which is useful in general-purpose scripts. It
provides the capabilities of install(DIRECTORY) and install(FILES) but
operates immediately instead of contributing to install scripts.
This teaches the undocumented file(INSTALL) command to deal with
relative paths. Relative input file paths are evaluated with respect to
the current source directory. Relative output file paths are evaluated
with respect to the current binary directory.
While this command is currently used only in cmake_install.cmake scripts
(in -P script mode), this cleans up its interface in preparation for a
documented signature.
The undocumented file(INSTALL) is implemented by a cmFileInstaller class
inside cmFileCommand. This refactors the class to split out code not
specific to installation into a cmFileCopier base class.
This creates a single cmFileInstaller method to dispatch installation of
symlinks, directories, and files. The change removes duplicate tests of
input file type and makes the decision more consistent.
While copying a directory the destination must have owner rwx
permissions. This corrects our check, this time with correct operator
precedence using parenthesis.
Previously we rejected all preprocessor definition values containing
spaces for the VS6 IDE generator. In fact VS6 does support spaces but
not in combination with '"', '$', or ';', and only if we use the sytnax
'-DNAME="value with spaces"' instead of '-D"NAME=value with spaces"'.
Now we support all definition values that do not have one of these
invalid pairs. See issue #8779.
This creates cmCTestGIT to drive CTest Update handling on git-based work
trees. Currently we always update to the head of the remote tracking
branch (git pull), so the nightly start time is ignored for Nightly
builds. A later change will address this. See issue #6994.
This factors parts of the svn update implementation that are useful for
any globally-versioning vcs tool into cmCTestGlobalVC. It will allow
the code to be shared among the support classes for most vcs tools.
The superclass of cmSystemTools is cmsys::SystemTools, which should be
referencable by just SystemTools from inside the class. Borland C++
does not seem to support this, so we use cmSystemTools instead.
The system tools GetParentDirectory method no longer removes the root
path component. This fixes cmSystemTools::FileExistsInParentDirectories
to not infinitely loop at when GetParentDirectory stops at the root.
When SystemTools::GetParentDirectory was fixed to never remove the root
path component from a full path we violated an assumption made by
IsSubDirectory that eventually GetParentDirectory returns an empty
string. This led to an infinite loop if the potential parent directory
is empty, so we explicitly avoid that case.
The previous change to this method broke cases where the input path does
not exist. The SystemTools::GetParentDirectory method is redundant with
the more robust SystemTools::GetFilenamePath. This replaces its
implementation to just call GetFilenamePath.
The cmSystemTools::RenameFile method returns type bool, but its
implementation on Windows returns the result of an API function that
returns BOOL. This change avoids the compiler warning.
This extends the "-E" command line mode with a "rename old new"
signature. The new command atomically renames a file or directory
within a single disk volume.
This moves the cmGeneratedFileStream::RenameFile method implementation
into cmSystemTools. It works only within a single filesystem volume,
but is atomic when the operating system permits.
All KWSys C symbol names begin with the KWSYS_NAMESPACE defined at
configuration time. For ease of editing we write canonical names with
the prefix 'kwsys' and use macros to map them to the configured prefix
at preprocessing time. In the case of standalone KWSys, the prefix is
'kwsys', so the macros were previously defined to their own names.
We now skip defining the macros in the identity case so that the final
symbol names are never themselves macros. This will allow the symbols
to be further transformed behind the scenes to help linkers in special
cases on some platforms.
Linking to a Windows shared library (.dll) requires only its import
library (.lib). This teaches CMake to recognize SHARED IMPORTED library
targets that set only IMPORTED_IMPLIB and not IMPORTED_LOCATION.
When an IMPORTED target provides no generic configuration and no match
for a desired configuration then we choose any available configuration.
This change corrects the choice when the first listed available
configuration does not really have a location.
Previously KWSys SystemInformation parsed this file assuming a strict
order and set of fields, but the order is not reliable. This
generalizes the implementation to support any order and extra fields.
The transitive link dependencies of a linked target must be followed in
its own scope, not in the scope of the original target that depends on
it. This is necessary since imported targets do not have global scope.
See issue #8843.
The previous wording of the VERBATIM option documentation in the
add_custom_command and add_custom_target commands was confusing. It
could be interpreted as the opposite of what the option means (no
escaping instead of escaping). This clarifies the documentation to
explicitly state that it escapes.
The value of CMAKE_CURRENT_LIST_FILE is supposed to be the list file
currently being executed. Before macros were introduced this was always
the context of the argument referencing the variable.
Our original implementation of macros replaced the context of command
arguments inside the macro with that of the arguments of the calling
context. This worked recursively, but only worked when macros had at
least one argument. Furthermore, it caused parsing errors of the
arguments to report the wrong location (calling context instead of line
with error).
The commit "Improve context for errors in macros" fixed the latter bug
by keeping the lexical context of command arguments in macros. It broke
evaluation of CMAKE_CURRENT_LIST_FILE because the calling context was no
longer preserved in the argument referencing the variable. However,
since our list file processing now maintains the proper value of
CMAKE_CURRENT_LIST_FILE with dynamic scope we no longer need the context
of the argument and can just evaluate the variable normally.
The add_definitions() command and COMPILE_DEFINITIONS dir/tgt/src
properties support preprocessor definitions with values. Previously
values were not supported in the VS6 generator even though the native
tool supports them. It is only values with spaces that VS6 does not
support. This enables support and instead complains only for values
with spaces. See issue #8779.
The CTest version control refactoring broke the value returned for the
ctest_update command's RETURN_VALUE argument. The value is supposed to
be the number of files updated, but the refactoring accidentally made it
the number of locally modified files after the update.
The RPATH target properties are initialized by CMAKE_<prop> variables at
target creation time. This notes the feature in the property
documentation. It is already noted in the variable documentation.
This creates a new mode of the foreach command which allows precise
iteration even over empty elements. This mode may be safely extended
with more keyword arguments in the future. The cost now is possibly
breaking scripts that iterate over a list of items beginning with 'IN',
but there is no other way to extend the syntax in a readable way.
This creates global property RULE_MESSAGES which can be set to disbale
per-rule progress and action reporting. On Windows, these reports may
cause a noticable delay due to the cost of starting extra processes.
This feature will allow scripted builds to avoid the cost since they do
not need detailed information anyway. This replaces the RULE_PROGRESS
property created earlier as it is more complete. See issue #8726.
This creates global property RULE_PROGRESS which can be set to disbale
per-rule progress reporting. On Windows, progress reports may cause a
noticable delay due to the cost of starting an extra process. This
feature will allow scripted builds to avoid the cost since they do not
need detailed progress anyway. See issue #8726.
Long ago the native build system generators needed HEADER_FILE_ONLY to
be set on header files to stop them from building. The modern
generators correctly handle headers without the help of this property.
This removes automatic setting of the property so that it can be used
reliably as an indicator of project author intention. It fixes VS IDE
project files to show header files normally instead of excluded (broken
by the fix for issue #7845).
This class is the old-style dependency scanner. It is needed only to
implement the output_required_files command. This change removes some
code not needed for that purpose, including a reference to the
HEADER_FILE_ONLY property.
This creates command mode add_test(NAME ...). This signature is
extensible with more keyword arguments later. The main purpose is to
enable automatic replacement of target names with built target file
locations. A side effect of this feature is support for tests that only
run under specific configurations.
This moves code which generates ADD_TEST and SET_TESTS_PROPERTIES calls
into CTestTestfile.cmake files out of cmLocalGenerator and into a
cmTestGenerator class. This will allow more advanced generation without
cluttering cmLocalGenerator. The cmTestGenerator class derives from
cmScriptGenerator to get support for per-configuration script
generation (not yet enabled).
A new cmScriptGenerator base class factors out the non-install-specific
part of cmInstallGenerator. This will be useful for other generators
that want per-configuration functionality.
its system include directories. These are catched in CMakeSystemSpecificInformation.cmake
(only with the Eclipse generator) and then written by the Eclipse generator
in the Eclipse project file. This way Eclipse can find the standard headers
(#7585)
Not sure CMakeSystemSpecificInformation.cmake is the best place to do this.
Alex
This property defines a list of values for a cache entry of type STRING.
A CMake GUI may optionally use a drop-down selection widget for the
entry instead of a generic text entry field. We do not enforce that the
value of the entry match one of the strings listed.
This factors out duplicated code into reusable methods, thus simplifying
writing and reading of cache entry help strings, keys, values, and
properties.
This moves the filtering of source files to before the production of
coverage log files in order to avoid producing a CoverageLog-*.xml file
for 100 filtered-out files. The change greatly reduces the number of
submitted coverage files when using label filters.
When performing multiple ctest_coverage() commands in a single CTest
instance we need to clear the list of CoverageLog-*.xml files for
submission. Otherwise if the current coverage run produces fewer log
files than the previous run CTest will attempt to submit non-existing
files.
This teaches ctest_coverage() to remove any existing CoverageLog-*.xml
when it creates new coverage results. Otherwise the next ctest_submit()
may submit old coverage log files which unnecessarily.
This adds the CACHE option to set_property and get_property commands.
This allows full control over cache entry information, so advanced users
can tweak their project cache as desired. The set_property command
allows only pre-defined CACHE properties to be set since others would
not persist anyway.
When a property does not exist we are supposed to return an empty value.
Previously if a property did not exist we just left the value of the
output variable unchanged. This teaches CMake to remove the definition
of the output variable in this case.
This teaches CTest to process coverage information only for object files
in targets containing labels of interest. This change also improves
loading of global coverage information by globbing only in each target
support directory instead of the entire build tree.
This generalizes the previous CMakeFiles/LabelFiles.txt created at the
top of the build tree to a CMakeFiles/TargetDirectories.txt file. It
lists the target support directories for all targets in the project.
Labels can still be loaded by looking for Labels.txt files in each
target directory.
During testing of the new message() signatures I mistakenly concluded
that SEND_ERROR stops processing. The corresponding commit enforced
this wrong behavior. This restores the correct behavior and fixes the
documentation accordingly.
Man page preformatted text needs an extra newline after the ending
marker to create a paragraph break. This bug was introduced by the
patch from issue #7797 to place explicit ".nf" and ".fi" markers around
preformatted blocks.
This teaches the command to interpret relative paths with respect to the
location of the invoking CMakeLists.txt file. The convention is already
used by most commands and won't change the behavior in script mode.
This moves the version numbers into an isolated configured header so
that not all of CMake needs to rebuild when the version changes.
Previously we had spaces, dashes and/or the word 'patch' randomly chosen
before the patch number. Now we always report version numbers in the
traditional format "<major>.<minor>.<patch>[-rc<rc>]".
We still use odd minor numbers for development versions. Now we also
use the CCYYMMDD date as the patch number of development versions, thus
allowing tests for exact CMake versions.
This cleans up the 'cmake --build' command-line interface:
- Rename --clean to --clean-first to better describe it.
- Replace --extra-options with a -- separator to simplify passing of
multiple native build tool options.
- Document the options in the main CMake man page description of the
--build option, and shares this with the usage message.
- Require --build to be the first argument when present.
- Move implementation into cmakemain where it belongs.
CTest encodes test and tool output in XML for dashboard submission.
This fixes the XML encoding implementation to not encode an invalid
character and instead put a human-readable tag in its place.
See issue #8647.
This teaches the helper commands 'cmake -E cmake_symlink_executable' and
'cmake -E cmake_symlink_library' to remove broken symlinks before
creating a symlink and report an error when the symlink cannot be
created. See issue #8654.
The <target>_EXPORTS macro defined for object files when built in a
shared library <target> should be put in the <DEFINES> make rule
replacement and not <FLAGS>. Also, it should honor the platform
variable CMAKE_<LANG>_DEFINE_FLAG. See issue #8107.
The second argument of add_subdirectory must name a unique binary
directory or the build files will clobber each other. This enforces
uniqueness with an error message.
This adds cmCTestVC::InitialCheckout and uses it in cmCTestUpdateHandler
to run the initial checkout command. The new implementation logs the
command in the update log consistently with the rest of the new update
implementation.
This fixes CMAKE_<LANG>_IMPLICIT_INCLUDE_DIRECTORIES to be used for all
generators instead of just those that construct their own compiler
command lines directly. See issue #8598.
It does not make sense to call the reverse Convert signature (for remote
paths corresponding to CMake-managed directories) with NONE or FULL
since they have no path. Patch from Modestas Vainius. See issue #7779.
This adds a new VCS update implementation to the cmCTestVC hierarchy and
removes it from cmCTestUpdateHandler. The new implementation has the
following advantages:
- Factorized implementation instead of monolithic function
- Logs vcs tool output as it is parsed (less memory, inline messages)
- Uses one global svn log instead of one log per file
- Reports changes on cvs branches (instead of latest trunk change)
- Generates simpler Update.xml (only one Directory element per dir)
Shared components of the new implementation appear in cmCTestVC and may
be re-used by subclasses for other VCS tools in the future.
This creates variable CMAKE_<LANG>_IMPLICIT_INCLUDE_DIRECTORIES to
specify implicit include directories on a per-language basis. This
replaces the previous platform-wide variable. It is necessary to
avoid explicit specification of -I/usr/include on some compilers
(such as HP aCC) because:
1.) It may break ordering among system include directories defined
internally by the compiler, thus getting wrong system headers.
2.) It tells the compiler to treat the system include directory
as a user include directory, enabling warnings in the headers.
See issue #8598.
This teaches cmCTestSVN::NoteNewRevision to save the repository URL
checked out in the work tree, the repository root, and the path below
the root to reach the full URL.
We used to suppress generation of -I/usr/include (and on OSX also
-I/usr/local/include). This behavior seems to cause more trouble than
it's worth, so I'm removing it until someone encounters the original
problem it fixed. See issue #8598.
The previous change to Source/cmDependsFortran.cxx while refactoring
implicit dependency scanning configuration rules completely broke
loading of the include file search path while scanning Fortran
dependencies. This adds the line that should have been added during the
previous change to load the include path correctly.
This adds the OPTIONAL option to the install(DIRECTORY) command. It
tells the installation rule that it is not an error if the source
directory does not exist. See issue #8394.
This class provides a RunProcess method to run a child process and send
its output to an abstract parsing interface. This also provides a
simple line parser and logger implementing the parsing interface.
In cmCTestUpdateHandler, this factors out version control tool detection
from the monolithic cmCTestUpdateHandler::ProcessHandler to separate
methods. This also places priority on detection of the tool managing
the source tree since using any other tool will cause errors.
This moves the initial checkout code from the monolithic
cmCTestUpdateHandler::ProcessHandler to a separate method
cmCTestUpdateHandler::InitialCheckout.
Previously we pre-quoted the command line tool path. This avoids it by
quoting the command everywhere it is used, thus preserving access to the
original, unquoted command.
This adds documentation of the APPEND option to the configure, build,
test, memcheck, and coverage commands. The docs leave specific
semantics for the dashboard server to define.
This corrects the terse documentation and adds detail to the full
documentation of some commands. It also normalizes the layout of the
documentation string endings to make adding lines easier.
Brad King
Bill Hoffman
Alexander Neundorf
Clinton Stimpson
Yumin Yuan
David Cole
Mathieu Malaterre
Francois Bertel