KWSys tries not to force anything on source files that include its
headers, but Borland warning 8027 leaves us no choice when we want to
have inline function definitions. This commit disables the warning for
the RegularExpression header and any file that includes it.
Until now CMake accidentally accepted add_subdirectory() and subdirs()
calls referring to directories that do not contain a CMakeLists.txt
file. We introduce CMake Policy CMP0014 to make this case an error.
This method tells the cmMakefile to read the input CMakeLists.txt file.
We factor out the call into a ReadInputFile method so it can be extended
without polluting the Configure method.
Much of the code in this method was dedicated to computing ObjectMaxPath
after configuring the directory. We move this last step into its own
ComputeObjectMaxPath method for better organization.
The cmLocalGenerator::Configure method sets its cmLocalGenerator
instance as the global generator's current local generator during
configuration. This commit refactors management of the current local
generator to use an automatic variable. This will allow early returns
from the method.
CMake Makefile generators silently ignore missing CMakeLists.txt files
and just treat the source directory as if it had an empty input file.
This will be addressed with a new CMake Policy, but for now we make the
VS generator consistent with the Makefile generator behavior. The VS
generator will need to handle the OLD behavior of the policy anyway.
The cmGlobalGenerator::AddTargetDepends method traces the dependencies
of targets recursively to collect the complete set of targets needed for
a given project (for VS .sln files). This commit teaches the method to
avoid tracing its dependencies more than once. Otherwise the code does
an all-paths walk needlessly.
We define the export(PACKAGE) command mode to store the location of the
build tree in the user package registry. This will help find_package
locate the package in the build tree. It simplies user workflow for
manually building a series of dependent projects.
A common user workflow is to build a series of dependent projects in
order. Each project locates its dependencies with find_package. We
introduce a "user package registry" to help find_package locate packages
built in non-standard search locations.
The registry explicitly stores locations of build trees providing
instances of a given package. There is no defined order among the
locations specified. These locations should provide package
configuration files (<package>-config.cmake) and package version files
(<package>-config-version.cmake) so that find_package will recognize the
packages and test version numbers.
We create target property "LINK_INTERFACE_MULTIPLICITY" and a per-config
version "LINK_INTERFACE_MULTIPLICITY_<CONFIG>". It sets the number of
times a linker should scan through a mutually dependent group of static
libraries. The largest value of this property on any target in the
group is used. This will help projects link even for extreme cases of
cyclic inter-target dependencies.
The 'binary' openmode does not exist on all compilers. We define macro
<kwsys>_ios_binary, where <kwsys> is the KWSys namespace, to refer to
std::ios::binary if it exists and 0 otherwise. Sample usage:
kwsys_ios::ifstream fin(fn, kwsys_ios::ios::in | kwsys_ios_binary);
In cmComputeLinkInformation::Compute we add implicit link information
from languages other than the linker language to the end of the link
line. This factors out that code into separate methods to improve
readability and organization.
CTest runs 'svn status' to identify modified and conflicting files in
the working directory. This commit fixes the interpretation of the 'X'
status, which corresponds to svn eXternals. This status should be
ignored rather than treated as a local modification.
This introduces a new syntax called "generator expressions" to the test
COMMAND option of the add_test(NAME) command mode. These expressions
have a syntax like $<TARGET_FILE:mytarget> and are evaluated during
build system generation. This syntax allows per-configuration target
output files to be referenced in test commands and arguments.
We creates methods IsDLLPlatform() and HasImportLibrary(). The former
returns true on Windows. The latter returns whether the target has a
DLL import library. It is true on Windows for shared libraries and
executables with exports.
We teach cmTestGenerator::GenerateScriptConfigs to use the general
cmLocalGenerator::EscapeForCMake method to write escaped test property
values into test scripts. This eliminates the previous hand-coded
escaping implementation.
The find_package commands looks at the "WhereBuild" registry entries
created by CMakeSetup and cmake-gui hoping that the project was recently
built. CMakeSetup created WhereBuild1..WhereBuild10 but cmake-gui
creates WhereBuild0-WhereBuild9.
This fixes find_package to look at WhereBuild0 so that the most recently
configured project can be found. It is important in the case that the
package to be found was the last one configured in cmake-gui but the
current project that is finding it is configured from the command line.
The try_compile command builds the cmTryCompileExec executable using the
cmTryCompileExec/fast target with Makefile generators in order to save
time since dependencies are not needed. However, in project mode the
command builds an entire source tree that may have dependencies.
Therefore we can use the /fast target approach only in one-source mode.
When building an entire source tree with try_compile instead of just a
single source file, it is possible that the CMakeLists.txt file in the
try-compiled project invokes try_compile. This commit fixes propagation
of language-initialization results from the outer-most project into any
number of try-compile levels.
The commit "Fix get_filename_component ABSOLUTE mode" broke the code
get_filename_component(cwd . ABSOLUTE)
because CTest scripts did not make cmMakefile::GetCurrentDirectory()
available. This commit fixes the problem by setting the proper
information on CTest script instances of cmMakefile.
This also makes CMAKE_CURRENT_SOURCE_DIR and CMAKE_CURRENT_BINARY_DIR
available to CTest scripts. They are set to the working directory at
script startup.
CMake 2.4 generates old-style cmake_install.cmake code including calls
to the file(INSTALL) command with the COMPONENTS argument. We need to
set CMAKE_INSTALL_SELF_2_4 for the whole install tree to prevent the
command from complaining in this special case. Previously this was
needed only in the QtDialog directory, but now it is needed in the
entire tree.
The commit "Consider link dependencies for link language" taught CMake
to propagate linker language preference from languages compiled into
libraries linked by a target. It turns out this should only be done for
some languages, such as C++, because normally the language of the
program entry point (main) should be used.
We introduce variable CMAKE_<LANG>_LINKER_PREFERENCE_PROPAGATES to tell
CMake whether a language should propagate its linker preference across
targets. Currently it is true only for C++.
This factors the decision logic out of cmTarget::ComputeLinkClosure into
dedicated class cmTargetSelectLinker. We replace several local
variables with a single object instance, and organize code into methods.
All global generator CreateLocalGenerator methods automatically
initialize the local generator instances with SetGlobalGenerator. In
several places we were calling SetGlobalGenerator again after receiving
the return value from CreateLocalGenerator. The double-initializations
leaked the resources allocated by the first call to SetGlobalGenerator.
This fix removes the unnecessary calls.
We list implicit link items of languages linked into a target but filter
them by the implicit libraries known to be passed by the main linker
language. Implicit link flags like "-z..." should not be filtered out
because they are not libraries.
In cmComputeLinkInformation we recognize link options that look like
library file names, but pass flags starting in '-' through untouched.
This fixes the ordering of the check to recognize '-' flags first in
case the rest of the option looks like a library file name, as in the
case of "-l:libfoo.a".
In cmComputeLinkInformation we construct regular expressions to
recognize library file names. This fixes the expressions to not allow a
colon (':') in the file name so that "-l:libfoo.a" is left alone.
Some AIX/gcc version combinations the <cstdio> header breaks when large
file support is enabled. See this GCC issue for details:
http://gcc.gnu.org/bugzilla/show_bug.cgi?id=20366
We work around the problem by enhancing the configuration check for
large file support to include <cstdio> when available. This will cause
LFS to be disabled when the above problem occurs.
This adds implicit libraries and search directories for languages linked
into a target other than the linker language to its link line. For
example, when linking an executable containing both C++ and Fortran code
the C++ linker is used but we need to add the Fortran libraries.
The variables
CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES
CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES
contain the implicit libraries and directories for each language.
Entries for the linker language are known to be implicit in the
generated link line. Entries for other languages that do not appear in
the known implicit set are listed explicitly at the end of the link
line.
The "Keep only FinalPass commands in memory" commit caused instances of
this command to be deleted after the InitialPass. Even though the
variable_watch command does not have a final pass, it does need to stay
alive because it owns the callback information.
In cmMakefile we save all invoked commands so that FinalPass can be
called on them later. Most commands have no final pass, so we should
keep only the few that do.
This teaches CMake to detect implicit link information for C, C++, and
Fortran compilers. We detect the implicit linker search directories and
implicit linker options for UNIX-like environments using verbose output
from compiler front-ends. We store results in new variables called
CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES
CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES
The implicit libraries can contain linker flags as well as library
names.
This teaches the command to recognize full windows paths when built on
UNIX. CollapseFullPath knows when the input path is relative better
than FileIsFullPath because the latter is only meant for paths from the
host platform.
Previously each new variable scope (subdirectory or function call) in
the CMake language created a complete copy of the key->value definition
map. This avoids the copy using transitive lookups up the scope stack.
Results of queries answered by parents are stored locally to maintain
locality of reference.
The class cmDefinitions replaces cmMakefile::DefinitionsMap, and is
aware of its enclosing scope. Each scope stores only the definitions
set (or unset!) inside it relative to the enclosing scope.
Generated makefiles for try-compile projects should never use color
output. On MSYS the color escapes end up in the try-compile output text
because there is no way to identify whether the output is going to a
color-capable terminal. Instead we should just always skip color for
try-compile projects.
This factors code out of cmOrderDirectories::CollectOriginalDirectories
into cmOrderDirectories::AddOriginalDirectories. Later a new call will
be added, and this is more readable anyway.
Add System_Parse_CommandForUnix to the KWSys System interface as a
utility to parse a unix-style command line. Move the existing
implementation out of ProcessUNIX. Add a flags argument reserved for
future use in providing additional behavior.
cmCTestScriptHandler, but have it load the new script CTestScriptMode.cmake
-> that makes it more flexible, also add a simple test that the system name
has been determined correctly
Alex
Now that languages are part of the link interface of a target we need to
export/import the information. A new IMPORTED_LINK_INTERFACE_LANGUAGES
property and per-config IMPORTED_LINK_INTERFACE_LANGUAGES_<CONFIG>
property specify the information for imported targets. The export() and
install(EXPORT) commands automatically set the properties.
Xcode does not seem to support direct requests for using the linker for
a particular language. It always infers the linker using the languages
in the source files. When no user source files compile with target's
linker language we add one to help Xcode pick the linker.
A typical use case is when a C executable links to a C++ archive. The
executable has no C++ source files but we need to use the C++ linker.
This teaches cmTarget to account for the languages compiled into link
dependencies when determining the linker language for its target.
We list the languages compiled into a static archive in its link
interface. Any target linking to it knows that the runtime libraries
for the static archive's languages must be available at link time. For
now this affects only the linker language selection, but later it will
allow CMake to automatically list the language runtime libraries.
This creates cmCTestHG to drive CTest Update handling on hg-based work
trees. Currently we always update to the head of the remote tracking
branch (hg pull), so the nightly start time is ignored for Nightly
builds. A later change will address this.
See issue #7879. Patch from Emmanuel Christophe. I modified the patch
slightly for code style, to finish up some parsing details, and to fix
the test.
This overload accepts a null-terminated string instead of requiring a
length. It is useful to pass some fake process output before and after
the real process output.
This adds another cast to avoid pointer conversion warnings.
Unfortunately C does not recognize implicit conversions that add
cv-qualifiers as well as C++ does.
The commit "Do not compute link language for LOCATION" was wrong. The
variables
CMAKE_STATIC_LIBRARY_PREFIX_Java
CMAKE_STATIC_LIBRARY_SUFFIX_Java
are used for building Java .jar files. This commit re-enables the
feature and documents the variables:
CMAKE_EXECUTABLE_SUFFIX_<LANG>
CMAKE_IMPORT_LIBRARY_PREFIX_<LANG>
CMAKE_IMPORT_LIBRARY_SUFFIX_<LANG>
CMAKE_SHARED_LIBRARY_PREFIX_<LANG>
CMAKE_SHARED_LIBRARY_SUFFIX_<LANG>
CMAKE_SHARED_MODULE_PREFIX_<LANG>
CMAKE_SHARED_MODULE_SUFFIX_<LANG>
CMAKE_STATIC_LIBRARY_PREFIX_<LANG>
CMAKE_STATIC_LIBRARY_SUFFIX_<LANG>
Instead of making separate, repetitive entries for the _<LANG> variable
documentation, we just mention the per-language name in the text of the
platform-wide variable documentation. Internally we keep undocumented
definitions of these properties to satisfy CMAKE_STRICT mode.
This passes the build configuration to most GetLinkerLanguage calls. In
the future the linker language will account for targets linked in each
configuration.
This simplifies computation of the lastKnownFileType attribute for
header files in Xcode projects. We now use a fixed mapping from
header file extension to attribute value. The value is just a hint to
the Xcode editor, so computing the target linker language is overkill.
The LOCATION property requires the full file name of a target to be
computed. Previously we computed the linker language for a target to
look up variables such as CMAKE_SHARED_LIBRARY_SUFFIX_<LANG>. This led
to locating all the source files immediately instead of delaying the
search to generation time. In the future even more computation will be
needed to get the linker language, so it is better to avoid it.
The _<LANG> versions of these variables are undocumented, not set in any
platform file we provide, and do not produce hits in google. This
change just removes the unused feature outright.
The new method centralizes loops that process raw OriginalLinkLibraries
to extract the link implementation (libraries linked into the target)
for each configuration. Results are computed on demand and then cached.
This simplifies link interface computation because the default case
trivially copies the link implementation.
These member structures are accessed only in the cmTarget implementation
so they do not need to be defined in the header. This cleanup also aids
Visual Studio 6 in compiling them.
The config-to-interface map in cmTarget should use case-insensitive
configuration names. The change avoids repeating work if the given
configuration has a different case than one already computed.
This fixes a dumb logic error introduced by the centralization of link
interface computation. It prevented link directories from alternate
configurations from getting listed by the OLD behavior of CMP0003 for
targets linked as transitive dependencies.
This method previously required the global generator to be passed, but
that was left from before cmTarget had its Makefile member. Now the
global generator can be retrieved automatically, so we can drop the
method argument.
When LINK_INTERFACE_LIBRARIES is not set we use the link implementation
to implicitly define the link interface. These changes centralize the
decision so that all linkable targets internally have a link interface.
This moves code implementing policy CMP0004 into cmTarget::CheckCMP0004.
The implementation is slightly simpler and can be re-used outside of
cmComputeLinkDepends.
This fixes cmTarget::GetLinkInterface to compute and return the link
interface in an exception-safe manner. We manage the link interface
returned by cmTarget::ComputeLinkInterface using auto_ptr.
This teaches the makefile generators to always pass the configuration
name to the cmTarget::GetDirectory method. Later this will allow
per-configuration target output directories, and it cleans up use of the
current API.
This creates cmTarget::GetOutputInfo to compute, cache, and lookup
target output directory information on a per-configuration basis. It
avoids re-computing the information every time it is needed.
Since utility targets have no main output files like executables or
libraries, they do not define an output directory. This removes a call
to cmTarget::GetDirectory from cmLocalVisualStudio{6,7}Generator for
such targets.
This member stores the build configuration for which Makefiles are being
generated. It saves repeated lookup of the equivalent member from
cmLocalUnixMakefileGenerator3, making code shorter and more readable.
Previously tests marked with WILL_FAIL have been reported by CTest as
...............***Failed - supposed to fail
when they correctly failed. Now we just report ".....Passed" because
there is no reason to draw attention to something that works as
expected.
Xcode 2.0 and below supported only one configuration, but 2.1 and above
support multiple configurations. In projects for the latter version we
have been generating a "global" set of buildSettings for each target in
addition to the per-configuration settings. These global settings are
not used by Xcode 2.1 and above, so we should not generate them.
The cmGlobalXCodeGenerator::CreateBuildSettings had the three arguments
productName, productType, and fileType that returned information used by only
one of the call sites. This change refactors that information into separate
methods named accordingly.
Previously we named Xcode targets using the output file name from one of the
configurations. This is not very friendly, especially because it changes with
CMAKE_BUILD_TYPE. Instead we should use the original logical target names for
the Xcode target names. This is also consistent with the way the other IDE
generators work.
CMake previously generated Xcode project files labeled as 2.4-compatible
by recent versions of Xcode (3.0 and 3.1). It is better to generate
native Xcode 3.0 and 3.1 projects. In particular, this can improve
build times by using the "Build independent targets in parallel"
feature.
Patch from Doug Gregor. See issue #9216.
files of the project, i.e. there is now a "CMake Files" folder additionally
to the "Sources", "Headers" and "Others" folders which already existed.
Patch by Daniel Teske.
Alex
This cleans up the Makefile generator's progress rule code. Instead of
keeping every cmMakefileTargetGenerator instance alive to generate
progress, we keep only the information necessary in a single table.
This approach keeps most of the code in cmGlobalUnixMakefileGenerator3,
thus simplifying its public interface.
The TortoiseCVS version of cvs.exe includes the '.exe' in cvs update
messages for files removed from the repository. This change accounts
for it in the regular expressions that match such lines. Now removed
files are properly reported by ctest_update() when using TortoiseCVS.
This fixes the CMP0012 description to have a one-line summary in the
'brief' section and the rest of the explanation in the 'full' section.
It makes the warning message shorter and improves formatting of the
policy documentation, especially in the HTML pages. The convention is
already used by all other policies.
Errors and warnings from the if() command always display the argument
list given to the command followed by an explanation of the problem.
This moves the argument list into a pre-formatted block and follows it
with a paragraph-form explanation. The result looks cleaner.
In CMake 2.6.3 and below we silently accepted duplicate build
directories whose build files would then conflict. At first this was
considured purely a bug that confused beginners but would not be used in
a real project. In CMake 2.6.4 we explicitly made it an error.
However, some real projects took advantage of this as a "feature" and
got lucky that the subtle build errors it can cause did not occur.
Therefore we need a policy to deal with the case more gracefully.
See issue #9173.
VS 6 forgets to create the output directory for an executable's import
library in case the exe dllexport-s symbols. We work around this VS bug
by creating a pre-link event on the executable target to make the
directory.
In cmLocalVisualStudio6Generator we generate pre-build, pre-link, and
post-build events into project files. This refactors the generation
code for the three event types into a private EventWriter class to avoid
duplicate code.
This moves creation of an executable's import library directory in VS
projects from the pre-build step to the pre-link step. It makes sense
to create the directory at the last moment.
In VS 7,8,9 executable targets we generate a build event to create the
output directory for the import library in case the executable marks
symbols with dllexport (VS forgets to create this directory). This
generalizes computation of the custom command line to support future use
with other VS versions.
This teaches the define_property command signature to accept multiple
arguments after the BRIEF_DOCS and FULL_DOCS keywords. We append the
arguments together, making specification of long documentation easier.
If an executable marks symbols with __declspec(dllexport) then VS
creates an import library for it. However, it forgets to create the
directory that will contain the import library if it is different from
the location of the executable. We work around this VS bug by creating
a pre-build event on the executable target to make the directory.
In cmLocalVisualStudio7Generator we generate pre-build, pre-link, and
post-build events into project files. This refactors the generation
code for the three event types into a private EventWriter class to avoid
duplicate code.
In Release builds the Borland compiler warns about code in its own
system headers. This blocks the warnings by disabling them where the
headers are included.
This replaces the Fortran dependency parser source's custom strcasecmp
implementation with one from KWSys String. It removes duplicate code
and avoids a Borland warning about inlining functions with 'while'.
The KWSys String implementation of strcasecmp initialized 'result'
immediately before assigning to it. Borland produces a warning in this
case, so this commit removes the extra initialization.
The fix for issue #9130 appends ':' to the end of the build-tree RPATH
unconditionally. This changes the fix to add ':' only when the RPATH is
not empty so that we do not create a build-tree RPATH with just ':'. An
empty RPATH produces no string at all, so there is no chance of merging
with a symbol name anyway.
We've chosen to drop our default dependence on xmlrpc. Thus we disable
the corresponding CTest submission method and remove the sources for
building xmlrpc locally. Users can re-enable the method by setting the
CTEST_USE_XMLRPC option to use a system-installed xmlrpc library.
In cmXMLParser::ReportXmlParseError we were accidentally passing a value
of type 'XML_Parser*' to expat methods instead of 'XML_Parser'. It was
not caught because XML_Parser was just 'void*' in the cmexpat version.
Newer system-installed expat versions catch the error because XML_Parser
is now a pointer to a real type. This correct the type.
In ELF binaries the .dynstr string table is used both for the RPATH
string and for program symbols. If a symbol name happens to match the
end of the build-tree RPATH string the linker is allowed to merge the
symbols.
We must not allow this when the RPATH string will be replaced during
installation because it will mangle the symbol. Therefore we always pad
the end of the build-tree RPATH with ':' if it will be replaced. Tools
tend not to use ':' at the end of symbol names, so it is unlikely to
conflict. See issue #9130.
This adds the Modules/Platform/OpenVMS.cmake platform file for OpenVMS.
We just use Unix-like rules to work with the GNV compiler front-end.
A problem with process execution currently prevents CMake link scripts
from working, so we avoid using them.
The VMS posix path emulation does not handle multiple '.' characters in
file names in all cases. This avoids adding extra '.'s to file and
directory names for target directories and generated files.
This teaches ConvertToUnixSlashes to convert VMS paths into posix-style
paths. We also set the DECC$FILENAME_UNIX_ONLY feature so the process
always sees posix-style paths on disk.
The Compaq compiler's std::unique algorithm followed by deletion of the
extra elements seems to crash. For now we'll accept the duplicate
dependencies on this platform.
This achieves basic process execution on OpenVMS. We use work-arounds
for different fork()/exec() behavior and a lack of select().
VMS emulates fork/exec using setjmp/longjmp to evaluate the child and
parent return cases from fork. Therefore both must be invoked from the
same function.
Since select() works only for sockets we use the BeOS-style polling
implementation. However, non-blocking reads on empty pipes cannot be
distinguished easily from the last read on a closed pipe. Therefore we
identify end of data by an empty read after the child terminates.
The Compaq compiler (on VMS) includes 'String.c' in source files that
use the stl string while looking for template definitions. This was the
true cause of double-inclusion of the 'kwsysPrivate.h' header. We work
around the problem by conditionally compiling the entire source file on
a condition only true when really building the source.
HP-UX uses both .sl and .so as extensions for shared libraries. This
teaches CMake to recognize .so shared libraries so they are treated
properly during link dependency analysis.
The BZR xml output plugin can use some encodings that are not recognized
by expat, which leads to "Error parsing bzr log xml: unknown encoding".
This works around the problem by giving expat a mapping, and adds a
test. Patch from Tom Vercauteren. See issue #6857.
Previously CTest would drop dashboard submissions at public.kitware.com
on the PublicDashboard project if there was no configuration. The
server no longer supports forwarding to cdash.org, so there is no point
in this default. Furthermore, there should be no default at all because
it could leak information about proprietary projects that are not
configured correctly.
This creates cmCTestBZR to drive CTest Update handling on bzr-based work
trees. Currently we always update to the head of the remote tracking
branch (bzr pull), so the nightly start time is ignored for Nightly
builds. A later change will address this. Patch from Tom Vercauteren.
See issue #6857.
The kwsysPrivate header double-inclusion check hits a false positive on
VMS for an undetermined reason. This simplifies the workaround and
documents it.
Zach Mullen
Ken Martin
Brad King
KWSys Robot
David Cole
Bill Hoffman
Clinton Stimpson
Dave Partyka
Alexander Neundorf
Mathieu Malaterre
Francois Bertel