kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
CMake/Source/cmCoreTryCompile.cxx

622 lines
20 KiB
C++
Raw Normal View History

Convert CMake to OSI-approved BSD License This converts the CMake license to a pure 3-clause OSI-approved BSD License. We drop the previous license clause requiring modified versions to be plainly marked. We also update the CMake copyright to cover the full development time range.
2009-09-28 19:43:28 +04:00
/*============================================================================
CMake - Cross Platform Makefile Generator
Improve try_compile and try_run error messages Use IssueMessage to give the messages context and better formatting.
2011-01-20 16:58:49 +03:00
Copyright 2000-2011 Kitware, Inc., Insight Software Consortium
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
Convert CMake to OSI-approved BSD License This converts the CMake license to a pure 3-clause OSI-approved BSD License. We drop the previous license clause requiring modified versions to be plainly marked. We also update the CMake copyright to cover the full development time range.
2009-09-28 19:43:28 +04:00
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
Convert CMake to OSI-approved BSD License This converts the CMake license to a pure 3-clause OSI-approved BSD License. We drop the previous license clause requiring modified versions to be plainly marked. We also update the CMake copyright to cover the full development time range.
2009-09-28 19:43:28 +04:00
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
#include "cmCoreTryCompile.h"
#include "cmake.h"
#include "cmCacheManager.h"
try_compile: Escape CMAKE_<lang>_FLAGS in test projects (#14268) If CMAKE_<lang>_FLAGS contains quotes or other CMake language characters they must be escaped when written into the generated CMakeLists.txt file so that the test project parses them properly. Teach the TryCompile test to cover this case by adding a flag with quotes into CMAKE_C_FLAGS during a C language try_compile.
2013-07-03 23:57:02 +04:00
#include "cmLocalGenerator.h"
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
#include "cmGlobalGenerator.h"
Handle targets in the LINK_LIBRARIES of try_compile. Imported targets are re-exported so that they can be used by the try_compile generated code with target_link_libraries. This makes the use of the cmake_expand_imported_targets macro obsolete. The macro is not able to expand the generator expressions which may appear in the IMPORTED_LINK_INTERFACE_LIBRARIES content. Instead it just sees them as 'not a target'.
2013-02-09 13:34:37 +04:00
#include "cmExportTryCompileFileGenerator.h"
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
#include <cmsys/Directory.hxx>
Handle targets in the LINK_LIBRARIES of try_compile. Imported targets are re-exported so that they can be used by the try_compile generated code with target_link_libraries. This makes the use of the cmake_expand_imported_targets macro obsolete. The macro is not able to expand the generator expressions which may appear in the IMPORTED_LINK_INTERFACE_LIBRARIES content. Instead it just sees them as 'not a target'.
2013-02-09 13:34:37 +04:00
#include <assert.h>
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv)
{
this->BinaryDirectory = argv[1].c_str();
this->OutputFile = "";
// which signature were we called with ?
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
this->SrcFileSignature = true;
Remove trailing whitespace Alex
2011-09-15 18:20:33 +04:00
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
const char* sourceDirectory = argv[2].c_str();
const char* projectName = 0;
const char* targetName = 0;
std::vector<std::string> cmakeFlags;
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
std::vector<std::string> compileDefs;
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
std::string outputVariable;
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
std::string copyFile;
try_compile: Add COPY_FILE_ERROR option to capture failure When the COPY_FILE operation fails optionally capture the error message with a COPY_FILE_ERROR option instead of reporting the error immediately. This gives callers a chance to do something else or report the error. Teach the RunCMake.try_compile test to cover bad argument combinations involving COPY_FILE_ERROR. Teach the TryCompile test to cover the case of a COPY_FILE error message captured by COPY_FILE_ERROR.
2013-07-09 23:26:15 +04:00
std::string copyFileError;
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
std::vector<cmTarget*> targets;
std::string libsToLink = " ";
bool useOldLinkLibs = true;
char targetNameBuf[64];
bool didOutputVariable = false;
bool didCopyFile = false;
try_compile: Add COPY_FILE_ERROR option to capture failure When the COPY_FILE operation fails optionally capture the error message with a COPY_FILE_ERROR option instead of reporting the error immediately. This gives callers a chance to do something else or report the error. Teach the RunCMake.try_compile test to cover bad argument combinations involving COPY_FILE_ERROR. Teach the TryCompile test to cover the case of a COPY_FILE error message captured by COPY_FILE_ERROR.
2013-07-09 23:26:15 +04:00
bool didCopyFileError = false;
try_compile: Add signature to allow multiple SOURCES Extend the signature try_compile(RESULT_VAR <bindir> <srcfile> ...) to allow multiple sources as try_compile(RESULT_VAR <bindir> SOURCES <srcfile>... ...) Process the sources to generate a CMakeLists.txt that enables all needed languages. Teach the TryCompile test to try cases with two sources of the same language and of mixed languages. Teach RunCMake.try_compile to cover error cases for the signature.
2013-06-06 21:54:44 +04:00
bool useSources = argv[2] == "SOURCES";
std::vector<std::string> sources;
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
enum Doing { DoingNone, DoingCMakeFlags, DoingCompileDefinitions,
try_compile: Add signature to allow multiple SOURCES Extend the signature try_compile(RESULT_VAR <bindir> <srcfile> ...) to allow multiple sources as try_compile(RESULT_VAR <bindir> SOURCES <srcfile>... ...) Process the sources to generate a CMakeLists.txt that enables all needed languages. Teach the TryCompile test to try cases with two sources of the same language and of mixed languages. Teach RunCMake.try_compile to cover error cases for the signature.
2013-06-06 21:54:44 +04:00
DoingLinkLibraries, DoingOutputVariable, DoingCopyFile,
try_compile: Add COPY_FILE_ERROR option to capture failure When the COPY_FILE operation fails optionally capture the error message with a COPY_FILE_ERROR option instead of reporting the error immediately. This gives callers a chance to do something else or report the error. Teach the RunCMake.try_compile test to cover bad argument combinations involving COPY_FILE_ERROR. Teach the TryCompile test to cover the case of a COPY_FILE error message captured by COPY_FILE_ERROR.
2013-07-09 23:26:15 +04:00
DoingCopyFileError, DoingSources };
try_compile: Add signature to allow multiple SOURCES Extend the signature try_compile(RESULT_VAR <bindir> <srcfile> ...) to allow multiple sources as try_compile(RESULT_VAR <bindir> SOURCES <srcfile>... ...) Process the sources to generate a CMakeLists.txt that enables all needed languages. Teach the TryCompile test to try cases with two sources of the same language and of mixed languages. Teach RunCMake.try_compile to cover error cases for the signature.
2013-06-06 21:54:44 +04:00
Doing doing = useSources? DoingSources : DoingNone;
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
for(size_t i=3; i < argv.size(); ++i)
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
{
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
if(argv[i] == "CMAKE_FLAGS")
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
{
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
doing = DoingCMakeFlags;
// CMAKE_FLAGS is the first argument because we need an argv[0] that
// is not used, so it matches regular command line parsing which has
// the program name as arg 0
cmakeFlags.push_back(argv[i]);
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
}
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
else if(argv[i] == "COMPILE_DEFINITIONS")
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
{
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
doing = DoingCompileDefinitions;
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
}
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
else if(argv[i] == "LINK_LIBRARIES")
Handle targets in the LINK_LIBRARIES of try_compile. Imported targets are re-exported so that they can be used by the try_compile generated code with target_link_libraries. This makes the use of the cmake_expand_imported_targets macro obsolete. The macro is not able to expand the generator expressions which may appear in the IMPORTED_LINK_INTERFACE_LIBRARIES content. Instead it just sees them as 'not a target'.
2013-02-09 13:34:37 +04:00
{
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
doing = DoingLinkLibraries;
Handle targets in the LINK_LIBRARIES of try_compile. Imported targets are re-exported so that they can be used by the try_compile generated code with target_link_libraries. This makes the use of the cmake_expand_imported_targets macro obsolete. The macro is not able to expand the generator expressions which may appear in the IMPORTED_LINK_INTERFACE_LIBRARIES content. Instead it just sees them as 'not a target'.
2013-02-09 13:34:37 +04:00
useOldLinkLibs = false;
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
}
else if(argv[i] == "OUTPUT_VARIABLE")
{
doing = DoingOutputVariable;
didOutputVariable = true;
}
else if(argv[i] == "COPY_FILE")
{
doing = DoingCopyFile;
didCopyFile = true;
}
try_compile: Add COPY_FILE_ERROR option to capture failure When the COPY_FILE operation fails optionally capture the error message with a COPY_FILE_ERROR option instead of reporting the error immediately. This gives callers a chance to do something else or report the error. Teach the RunCMake.try_compile test to cover bad argument combinations involving COPY_FILE_ERROR. Teach the TryCompile test to cover the case of a COPY_FILE error message captured by COPY_FILE_ERROR.
2013-07-09 23:26:15 +04:00
else if(argv[i] == "COPY_FILE_ERROR")
{
doing = DoingCopyFileError;
didCopyFileError = true;
}
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
else if(doing == DoingCMakeFlags)
{
cmakeFlags.push_back(argv[i]);
}
else if(doing == DoingCompileDefinitions)
{
compileDefs.push_back(argv[i]);
}
else if(doing == DoingLinkLibraries)
{
libsToLink += "\"" + cmSystemTools::TrimWhitespace(argv[i]) + "\" ";
if(cmTarget *tgt = this->Makefile->FindTargetToUse(argv[i].c_str()))
Handle targets in the LINK_LIBRARIES of try_compile. Imported targets are re-exported so that they can be used by the try_compile generated code with target_link_libraries. This makes the use of the cmake_expand_imported_targets macro obsolete. The macro is not able to expand the generator expressions which may appear in the IMPORTED_LINK_INTERFACE_LIBRARIES content. Instead it just sees them as 'not a target'.
2013-02-09 13:34:37 +04:00
{
switch(tgt->GetType())
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
{
case cmTarget::SHARED_LIBRARY:
case cmTarget::STATIC_LIBRARY:
export: Add support for INTERFACE_LIBRARY targets
2012-11-20 13:58:15 +04:00
case cmTarget::INTERFACE_LIBRARY:
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
case cmTarget::UNKNOWN_LIBRARY:
Handle targets in the LINK_LIBRARIES of try_compile. Imported targets are re-exported so that they can be used by the try_compile generated code with target_link_libraries. This makes the use of the cmake_expand_imported_targets macro obsolete. The macro is not able to expand the generator expressions which may appear in the IMPORTED_LINK_INTERFACE_LIBRARIES content. Instead it just sees them as 'not a target'.
2013-02-09 13:34:37 +04:00
break;
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
case cmTarget::EXECUTABLE:
if (tgt->IsExecutableWithExports())
{
break;
}
default:
this->Makefile->IssueMessage(cmake::FATAL_ERROR,
"Only libraries may be used as try_compile IMPORTED "
"LINK_LIBRARIES. Got " + std::string(tgt->GetName()) + " of "
"type " + tgt->GetTargetTypeName(tgt->GetType()) + ".");
return -1;
}
if (tgt->IsImported())
Handle targets in the LINK_LIBRARIES of try_compile. Imported targets are re-exported so that they can be used by the try_compile generated code with target_link_libraries. This makes the use of the cmake_expand_imported_targets macro obsolete. The macro is not able to expand the generator expressions which may appear in the IMPORTED_LINK_INTERFACE_LIBRARIES content. Instead it just sees them as 'not a target'.
2013-02-09 13:34:37 +04:00
{
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
targets.push_back(tgt);
Handle targets in the LINK_LIBRARIES of try_compile. Imported targets are re-exported so that they can be used by the try_compile generated code with target_link_libraries. This makes the use of the cmake_expand_imported_targets macro obsolete. The macro is not able to expand the generator expressions which may appear in the IMPORTED_LINK_INTERFACE_LIBRARIES content. Instead it just sees them as 'not a target'.
2013-02-09 13:34:37 +04:00
}
}
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
}
else if(doing == DoingOutputVariable)
{
outputVariable = argv[i].c_str();
doing = DoingNone;
}
else if(doing == DoingCopyFile)
{
copyFile = argv[i].c_str();
doing = DoingNone;
}
try_compile: Add COPY_FILE_ERROR option to capture failure When the COPY_FILE operation fails optionally capture the error message with a COPY_FILE_ERROR option instead of reporting the error immediately. This gives callers a chance to do something else or report the error. Teach the RunCMake.try_compile test to cover bad argument combinations involving COPY_FILE_ERROR. Teach the TryCompile test to cover the case of a COPY_FILE error message captured by COPY_FILE_ERROR.
2013-07-09 23:26:15 +04:00
else if(doing == DoingCopyFileError)
{
copyFileError = argv[i].c_str();
doing = DoingNone;
}
try_compile: Add signature to allow multiple SOURCES Extend the signature try_compile(RESULT_VAR <bindir> <srcfile> ...) to allow multiple sources as try_compile(RESULT_VAR <bindir> SOURCES <srcfile>... ...) Process the sources to generate a CMakeLists.txt that enables all needed languages. Teach the TryCompile test to try cases with two sources of the same language and of mixed languages. Teach RunCMake.try_compile to cover error cases for the signature.
2013-06-06 21:54:44 +04:00
else if(doing == DoingSources)
{
sources.push_back(argv[i]);
}
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
else if(i == 3)
{
this->SrcFileSignature = false;
projectName = argv[i].c_str();
}
else if(i == 4 && !this->SrcFileSignature)
{
targetName = argv[i].c_str();
}
else
{
cmOStringStream m;
m << "try_compile given unknown argument \"" << argv[i] << "\".";
this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, m.str());
Handle targets in the LINK_LIBRARIES of try_compile. Imported targets are re-exported so that they can be used by the try_compile generated code with target_link_libraries. This makes the use of the cmake_expand_imported_targets macro obsolete. The macro is not able to expand the generator expressions which may appear in the IMPORTED_LINK_INTERFACE_LIBRARIES content. Instead it just sees them as 'not a target'.
2013-02-09 13:34:37 +04:00
}
}
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
if(didCopyFile && copyFile.empty())
ENH: add COPY_FILE argument to TRY_COMPILE, so the compiled executable can be used e.g. for getting strings out of it. Alex
2007-05-24 20:06:59 +04:00
{
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
this->Makefile->IssueMessage(cmake::FATAL_ERROR,
"COPY_FILE must be followed by a file path");
return -1;
ENH: add COPY_FILE argument to TRY_COMPILE, so the compiled executable can be used e.g. for getting strings out of it. Alex
2007-05-24 20:06:59 +04:00
}
Remove trailing whitespace Alex
2011-09-15 18:20:33 +04:00
try_compile: Add COPY_FILE_ERROR option to capture failure When the COPY_FILE operation fails optionally capture the error message with a COPY_FILE_ERROR option instead of reporting the error immediately. This gives callers a chance to do something else or report the error. Teach the RunCMake.try_compile test to cover bad argument combinations involving COPY_FILE_ERROR. Teach the TryCompile test to cover the case of a COPY_FILE error message captured by COPY_FILE_ERROR.
2013-07-09 23:26:15 +04:00
if(didCopyFileError && copyFileError.empty())
{
this->Makefile->IssueMessage(cmake::FATAL_ERROR,
"COPY_FILE_ERROR must be followed by a variable name");
return -1;
}
if(didCopyFileError && !didCopyFile)
{
this->Makefile->IssueMessage(cmake::FATAL_ERROR,
"COPY_FILE_ERROR may be used only with COPY_FILE");
return -1;
}
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
if(didOutputVariable && outputVariable.empty())
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
{
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
this->Makefile->IssueMessage(cmake::FATAL_ERROR,
"OUTPUT_VARIABLE must be followed by a variable name");
return -1;
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
}
try_compile: Add signature to allow multiple SOURCES Extend the signature try_compile(RESULT_VAR <bindir> <srcfile> ...) to allow multiple sources as try_compile(RESULT_VAR <bindir> SOURCES <srcfile>... ...) Process the sources to generate a CMakeLists.txt that enables all needed languages. Teach the TryCompile test to try cases with two sources of the same language and of mixed languages. Teach RunCMake.try_compile to cover error cases for the signature.
2013-06-06 21:54:44 +04:00
if(useSources && sources.empty())
{
this->Makefile->IssueMessage(cmake::FATAL_ERROR,
"SOURCES must be followed by at least one source file");
return -1;
}
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
// compute the binary dir when TRY_COMPILE is called with a src file
// signature
if (this->SrcFileSignature)
{
this->BinaryDirectory += cmake::GetCMakeFilesDirectory();
this->BinaryDirectory += "/CMakeTmp";
}
else
{
// only valid for srcfile signatures
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
if (compileDefs.size())
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
{
Improve try_compile and try_run error messages Use IssueMessage to give the messages context and better formatting.
2011-01-20 16:58:49 +03:00
this->Makefile->IssueMessage(cmake::FATAL_ERROR,
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
"COMPILE_DEFINITIONS specified on a srcdir type TRY_COMPILE");
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
return -1;
}
ENH: add COPY_FILE argument to TRY_COMPILE, so the compiled executable can be used e.g. for getting strings out of it. Alex
2007-05-24 20:06:59 +04:00
if (copyFile.size())
{
Improve try_compile and try_run error messages Use IssueMessage to give the messages context and better formatting.
2011-01-20 16:58:49 +03:00
this->Makefile->IssueMessage(cmake::FATAL_ERROR,
"COPY_FILE specified on a srcdir type TRY_COMPILE");
ENH: add COPY_FILE argument to TRY_COMPILE, so the compiled executable can be used e.g. for getting strings out of it. Alex
2007-05-24 20:06:59 +04:00
return -1;
}
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
}
// make sure the binary directory exists
cmSystemTools::MakeDirectory(this->BinaryDirectory.c_str());
Remove trailing whitespace Alex
2011-09-15 18:20:33 +04:00
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
// do not allow recursive try Compiles
if (this->BinaryDirectory == this->Makefile->GetHomeOutputDirectory())
{
Improve try_compile and try_run error messages Use IssueMessage to give the messages context and better formatting.
2011-01-20 16:58:49 +03:00
cmOStringStream e;
e << "Attempt at a recursive or nested TRY_COMPILE in directory\n"
<< " " << this->BinaryDirectory << "\n";
this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
return -1;
}
Remove trailing whitespace Alex
2011-09-15 18:20:33 +04:00
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
std::string outFileName = this->BinaryDirectory + "/CMakeLists.txt";
// which signature are we using? If we are using var srcfile bindir
if (this->SrcFileSignature)
{
// remove any CMakeCache.txt files so we will have a clean test
std::string ccFile = this->BinaryDirectory + "/CMakeCache.txt";
cmSystemTools::RemoveFile(ccFile.c_str());
Remove trailing whitespace Alex
2011-09-15 18:20:33 +04:00
try_compile: Add signature to allow multiple SOURCES Extend the signature try_compile(RESULT_VAR <bindir> <srcfile> ...) to allow multiple sources as try_compile(RESULT_VAR <bindir> SOURCES <srcfile>... ...) Process the sources to generate a CMakeLists.txt that enables all needed languages. Teach the TryCompile test to try cases with two sources of the same language and of mixed languages. Teach RunCMake.try_compile to cover error cases for the signature.
2013-06-06 21:54:44 +04:00
// Choose sources.
if(!useSources)
{
sources.push_back(argv[2]);
}
// Detect languages to enable.
try_compile: Escape CMAKE_<lang>_FLAGS in test projects (#14268) If CMAKE_<lang>_FLAGS contains quotes or other CMake language characters they must be escaped when written into the generated CMakeLists.txt file so that the test project parses them properly. Teach the TryCompile test to cover this case by adding a flag with quotes into CMAKE_C_FLAGS during a C language try_compile.
2013-07-03 23:57:02 +04:00
cmLocalGenerator* lg = this->Makefile->GetLocalGenerator();
cmGlobalGenerator* gg = lg->GetGlobalGenerator();
try_compile: Add signature to allow multiple SOURCES Extend the signature try_compile(RESULT_VAR <bindir> <srcfile> ...) to allow multiple sources as try_compile(RESULT_VAR <bindir> SOURCES <srcfile>... ...) Process the sources to generate a CMakeLists.txt that enables all needed languages. Teach the TryCompile test to try cases with two sources of the same language and of mixed languages. Teach RunCMake.try_compile to cover error cases for the signature.
2013-06-06 21:54:44 +04:00
std::set<std::string> testLangs;
for(std::vector<std::string>::iterator si = sources.begin();
si != sources.end(); ++si)
{
std::string ext = cmSystemTools::GetFilenameLastExtension(*si);
if(const char* lang = gg->GetLanguageFromExtension(ext.c_str()))
{
testLangs.insert(lang);
}
else
{
cmOStringStream err;
err << "Unknown extension \"" << ext << "\" for file\n"
<< " " << *si << "\n"
<< "try_compile() works only for enabled languages. "
<< "Currently these are:\n ";
std::vector<std::string> langs;
gg->GetEnabledLanguages(langs);
for(std::vector<std::string>::iterator l = langs.begin();
l != langs.end(); ++l)
{
err << " " << *l;
}
err << "\nSee project() command to enable other languages.";
this->Makefile->IssueMessage(cmake::FATAL_ERROR, err.str());
return -1;
}
}
Run vim spellcheck on some files
2012-02-26 22:44:20 +04:00
// we need to create a directory and CMakeLists file etc...
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
// first create the directories
sourceDirectory = this->BinaryDirectory.c_str();
Run vim spellcheck on some files
2012-02-26 22:44:20 +04:00
// now create a CMakeLists.txt file in that directory
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
FILE *fout = fopen(outFileName.c_str(),"w");
if (!fout)
{
Improve try_compile and try_run error messages Use IssueMessage to give the messages context and better formatting.
2011-01-20 16:58:49 +03:00
cmOStringStream e;
e << "Failed to open\n"
<< " " << outFileName.c_str() << "\n"
<< cmSystemTools::GetLastSystemError();
this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
return -1;
}
const char* def = this->Makefile->GetDefinition("CMAKE_MODULE_PATH");
Write full version into try_compile CMakeLists Pass the full version to cmake_minimum_required(VERSION) in generated CMake files for try_compile projects. This tells CMake not to use any backward compatibility behavior while processing code it generates.
2010-12-14 17:36:06 +03:00
fprintf(fout, "cmake_minimum_required(VERSION %u.%u.%u.%u)\n",
cmVersion::GetMajorVersion(), cmVersion::GetMinorVersion(),
cmVersion::GetPatchVersion(), cmVersion::GetTweakVersion());
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
if(def)
{
Generate modern-style cmake code. The commits 9db31162 (Remove CMake-language block-end command arguments, 2012-08-13) and 77543bde (Convert CMake-language commands to lower case, 2012-08-13) changed most cmake code to use lowercase commands and no parameters in termination commands. However, those changes excluded cmake code generated in c++ by cmake. Make a similar style change to code generated by cmake.
2013-08-22 13:30:19 +04:00
fprintf(fout, "set(CMAKE_MODULE_PATH %s)\n", def);
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
}
Honor CMAKE_USER_MAKE_RULES_OVERRIDE in try_compile (#10902)
2010-06-29 16:28:47 +04:00
try_compile: Add signature to allow multiple SOURCES Extend the signature try_compile(RESULT_VAR <bindir> <srcfile> ...) to allow multiple sources as try_compile(RESULT_VAR <bindir> SOURCES <srcfile>... ...) Process the sources to generate a CMakeLists.txt that enables all needed languages. Teach the TryCompile test to try cases with two sources of the same language and of mixed languages. Teach RunCMake.try_compile to cover error cases for the signature.
2013-06-06 21:54:44 +04:00
std::string projectLangs;
for(std::set<std::string>::iterator li = testLangs.begin();
li != testLangs.end(); ++li)
{
projectLangs += " " + *li;
std::string rulesOverrideBase = "CMAKE_USER_MAKE_RULES_OVERRIDE";
std::string rulesOverrideLang = rulesOverrideBase + "_" + *li;
if(const char* rulesOverridePath =
this->Makefile->GetDefinition(rulesOverrideLang.c_str()))
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
{
Generate modern-style cmake code. The commits 9db31162 (Remove CMake-language block-end command arguments, 2012-08-13) and 77543bde (Convert CMake-language commands to lower case, 2012-08-13) changed most cmake code to use lowercase commands and no parameters in termination commands. However, those changes excluded cmake code generated in c++ by cmake. Make a similar style change to code generated by cmake.
2013-08-22 13:30:19 +04:00
fprintf(fout, "set(%s \"%s\")\n",
try_compile: Add signature to allow multiple SOURCES Extend the signature try_compile(RESULT_VAR <bindir> <srcfile> ...) to allow multiple sources as try_compile(RESULT_VAR <bindir> SOURCES <srcfile>... ...) Process the sources to generate a CMakeLists.txt that enables all needed languages. Teach the TryCompile test to try cases with two sources of the same language and of mixed languages. Teach RunCMake.try_compile to cover error cases for the signature.
2013-06-06 21:54:44 +04:00
rulesOverrideLang.c_str(), rulesOverridePath);
}
else if(const char* rulesOverridePath2 =
this->Makefile->GetDefinition(rulesOverrideBase.c_str()))
{
Generate modern-style cmake code. The commits 9db31162 (Remove CMake-language block-end command arguments, 2012-08-13) and 77543bde (Convert CMake-language commands to lower case, 2012-08-13) changed most cmake code to use lowercase commands and no parameters in termination commands. However, those changes excluded cmake code generated in c++ by cmake. Make a similar style change to code generated by cmake.
2013-08-22 13:30:19 +04:00
fprintf(fout, "set(%s \"%s\")\n",
try_compile: Add signature to allow multiple SOURCES Extend the signature try_compile(RESULT_VAR <bindir> <srcfile> ...) to allow multiple sources as try_compile(RESULT_VAR <bindir> SOURCES <srcfile>... ...) Process the sources to generate a CMakeLists.txt that enables all needed languages. Teach the TryCompile test to try cases with two sources of the same language and of mixed languages. Teach RunCMake.try_compile to cover error cases for the signature.
2013-06-06 21:54:44 +04:00
rulesOverrideBase.c_str(), rulesOverridePath2);
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
}
}
Generate modern-style cmake code. The commits 9db31162 (Remove CMake-language block-end command arguments, 2012-08-13) and 77543bde (Convert CMake-language commands to lower case, 2012-08-13) changed most cmake code to use lowercase commands and no parameters in termination commands. However, those changes excluded cmake code generated in c++ by cmake. Make a similar style change to code generated by cmake.
2013-08-22 13:30:19 +04:00
fprintf(fout, "project(CMAKE_TRY_COMPILE%s)\n", projectLangs.c_str());
fprintf(fout, "set(CMAKE_VERBOSE_MAKEFILE 1)\n");
try_compile: Add signature to allow multiple SOURCES Extend the signature try_compile(RESULT_VAR <bindir> <srcfile> ...) to allow multiple sources as try_compile(RESULT_VAR <bindir> SOURCES <srcfile>... ...) Process the sources to generate a CMakeLists.txt that enables all needed languages. Teach the TryCompile test to try cases with two sources of the same language and of mixed languages. Teach RunCMake.try_compile to cover error cases for the signature.
2013-06-06 21:54:44 +04:00
for(std::set<std::string>::iterator li = testLangs.begin();
li != testLangs.end(); ++li)
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
{
try_compile: Add signature to allow multiple SOURCES Extend the signature try_compile(RESULT_VAR <bindir> <srcfile> ...) to allow multiple sources as try_compile(RESULT_VAR <bindir> SOURCES <srcfile>... ...) Process the sources to generate a CMakeLists.txt that enables all needed languages. Teach the TryCompile test to try cases with two sources of the same language and of mixed languages. Teach RunCMake.try_compile to cover error cases for the signature.
2013-06-06 21:54:44 +04:00
std::string langFlags = "CMAKE_" + *li + "_FLAGS";
try_compile: Escape CMAKE_<lang>_FLAGS in test projects (#14268) If CMAKE_<lang>_FLAGS contains quotes or other CMake language characters they must be escaped when written into the generated CMakeLists.txt file so that the test project parses them properly. Teach the TryCompile test to cover this case by adding a flag with quotes into CMAKE_C_FLAGS during a C language try_compile.
2013-07-03 23:57:02 +04:00
const char* flags = this->Makefile->GetDefinition(langFlags.c_str());
Generate modern-style cmake code. The commits 9db31162 (Remove CMake-language block-end command arguments, 2012-08-13) and 77543bde (Convert CMake-language commands to lower case, 2012-08-13) changed most cmake code to use lowercase commands and no parameters in termination commands. However, those changes excluded cmake code generated in c++ by cmake. Make a similar style change to code generated by cmake.
2013-08-22 13:30:19 +04:00
fprintf(fout, "set(CMAKE_%s_FLAGS %s)\n", li->c_str(),
try_compile: Escape CMAKE_<lang>_FLAGS in test projects (#14268) If CMAKE_<lang>_FLAGS contains quotes or other CMake language characters they must be escaped when written into the generated CMakeLists.txt file so that the test project parses them properly. Teach the TryCompile test to cover this case by adding a flag with quotes into CMAKE_C_FLAGS during a C language try_compile.
2013-07-03 23:57:02 +04:00
lg->EscapeForCMake(flags?flags:"").c_str());
Generate modern-style cmake code. The commits 9db31162 (Remove CMake-language block-end command arguments, 2012-08-13) and 77543bde (Convert CMake-language commands to lower case, 2012-08-13) changed most cmake code to use lowercase commands and no parameters in termination commands. However, those changes excluded cmake code generated in c++ by cmake. Make a similar style change to code generated by cmake.
2013-08-22 13:30:19 +04:00
fprintf(fout, "set(CMAKE_%s_FLAGS \"${CMAKE_%s_FLAGS}"
try_compile: Escape CMAKE_<lang>_FLAGS in test projects (#14268) If CMAKE_<lang>_FLAGS contains quotes or other CMake language characters they must be escaped when written into the generated CMakeLists.txt file so that the test project parses them properly. Teach the TryCompile test to cover this case by adding a flag with quotes into CMAKE_C_FLAGS during a C language try_compile.
2013-07-03 23:57:02 +04:00
" ${COMPILE_DEFINITIONS}\")\n", li->c_str(), li->c_str());
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
}
Generate modern-style cmake code. The commits 9db31162 (Remove CMake-language block-end command arguments, 2012-08-13) and 77543bde (Convert CMake-language commands to lower case, 2012-08-13) changed most cmake code to use lowercase commands and no parameters in termination commands. However, those changes excluded cmake code generated in c++ by cmake. Make a similar style change to code generated by cmake.
2013-08-22 13:30:19 +04:00
fprintf(fout, "include_directories(${INCLUDE_DIRECTORIES})\n");
fprintf(fout, "set(CMAKE_SUPPRESS_REGENERATION 1)\n");
fprintf(fout, "link_directories(${LINK_DIRECTORIES})\n");
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
// handle any compile flags we need to pass on
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
if (compileDefs.size())
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
{
Generate modern-style cmake code. The commits 9db31162 (Remove CMake-language block-end command arguments, 2012-08-13) and 77543bde (Convert CMake-language commands to lower case, 2012-08-13) changed most cmake code to use lowercase commands and no parameters in termination commands. However, those changes excluded cmake code generated in c++ by cmake. Make a similar style change to code generated by cmake.
2013-08-22 13:30:19 +04:00
fprintf(fout, "add_definitions( ");
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
for (size_t i = 0; i < compileDefs.size(); ++i)
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
{
try_compile: Refactor argument processing Process all arguments in a single loop using a simple state machine. While at it, fix some error message typos. Also allow LINK_LIBRARIES with no actual libraries to disable use of the -DLINK_LIBRARIES=... from the CMAKE_FLAGS. This was already possible in the old logic if LINK_LIBRARIES was immediately followed by another keyword argument instead of the end of the argument list, so allow it in general. Update the RunCMake.try_compile test cases accordingly.
2013-05-15 23:30:34 +04:00
fprintf(fout,"%s ",compileDefs[i].c_str());
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
}
fprintf(fout, ")\n");
}
ENH: determine typesize by compiling a file and reading strings from the compiled output. Tested with various gcc, XCode, MSVC7, sdcc For OSX when doing TRY_COMPILE() CMAKE_OSX_ARCHITECTURES is used, if there are different results an error is generated. CMAKE_OSX_ARCHITECTURES can be overwritten for the TRY_COMPILES with CMAKE_TRY_COMPILE_OSX_ARCHITECTURES. Alex
2007-06-05 01:08:46 +04:00
Handle targets in the LINK_LIBRARIES of try_compile. Imported targets are re-exported so that they can be used by the try_compile generated code with target_link_libraries. This makes the use of the cmake_expand_imported_targets macro obsolete. The macro is not able to expand the generator expressions which may appear in the IMPORTED_LINK_INTERFACE_LIBRARIES content. Instead it just sees them as 'not a target'.
2013-02-09 13:34:37 +04:00
/* Use a random file name to avoid rapid creation and deletion
of the same executable name (some filesystems fail on that). */
sprintf(targetNameBuf, "cmTryCompileExec%u",
cmSystemTools::RandomSeed());
targetName = targetNameBuf;
if (!targets.empty())
{
std::string fname = "/" + std::string(targetName) + "Targets.cmake";
cmExportTryCompileFileGenerator tcfg;
tcfg.SetExportFile((this->BinaryDirectory + fname).c_str());
tcfg.SetExports(targets);
tcfg.SetConfig(this->Makefile->GetDefinition(
"CMAKE_TRY_COMPILE_CONFIGURATION"));
if(!tcfg.GenerateImportFile())
{
this->Makefile->IssueMessage(cmake::FATAL_ERROR,
"could not write export file.");
try_compile: add missing fclose() to recently added error case In commit 236133e7 (Handle targets in the LINK_LIBRARIES of try_compile, 2013-02-09) an error return case was added without closing the file in progress. Add the missing fclose() call. Spotted by sevenhill.
2013-04-16 11:15:35 +04:00
fclose(fout);
Handle targets in the LINK_LIBRARIES of try_compile. Imported targets are re-exported so that they can be used by the try_compile generated code with target_link_libraries. This makes the use of the cmake_expand_imported_targets macro obsolete. The macro is not able to expand the generator expressions which may appear in the IMPORTED_LINK_INTERFACE_LIBRARIES content. Instead it just sees them as 'not a target'.
2013-02-09 13:34:37 +04:00
return -1;
}
fprintf(fout,
"\ninclude(\"${CMAKE_CURRENT_LIST_DIR}/%s\")\n\n",
fname.c_str());
}
ENH: determine typesize by compiling a file and reading strings from the compiled output. Tested with various gcc, XCode, MSVC7, sdcc For OSX when doing TRY_COMPILE() CMAKE_OSX_ARCHITECTURES is used, if there are different results an error is generated. CMAKE_OSX_ARCHITECTURES can be overwritten for the TRY_COMPILES with CMAKE_TRY_COMPILE_OSX_ARCHITECTURES. Alex
2007-06-05 01:08:46 +04:00
/* for the TRY_COMPILEs we want to be able to specify the architecture.
Remove trailing whitespace Alex
2011-09-15 18:20:33 +04:00
So the user can set CMAKE_OSX_ARCHITECTURE to i386;ppc and then set
ENH: determine typesize by compiling a file and reading strings from the compiled output. Tested with various gcc, XCode, MSVC7, sdcc For OSX when doing TRY_COMPILE() CMAKE_OSX_ARCHITECTURES is used, if there are different results an error is generated. CMAKE_OSX_ARCHITECTURES can be overwritten for the TRY_COMPILES with CMAKE_TRY_COMPILE_OSX_ARCHITECTURES. Alex
2007-06-05 01:08:46 +04:00
CMAKE_TRY_COMPILE_OSX_ARCHITECTURE first to i386 and then to ppc to
Remove trailing whitespace Alex
2011-09-15 18:20:33 +04:00
have the tests run for each specific architecture. Since
cmLocalGenerator doesn't allow building for "the other"
CMAKE_DO_TRY_COMPILE is no longer used
2010-09-15 01:51:43 +04:00
architecture only via CMAKE_OSX_ARCHITECTURES.
ENH: determine typesize by compiling a file and reading strings from the compiled output. Tested with various gcc, XCode, MSVC7, sdcc For OSX when doing TRY_COMPILE() CMAKE_OSX_ARCHITECTURES is used, if there are different results an error is generated. CMAKE_OSX_ARCHITECTURES can be overwritten for the TRY_COMPILES with CMAKE_TRY_COMPILE_OSX_ARCHITECTURES. Alex
2007-06-05 01:08:46 +04:00
*/
if(this->Makefile->GetDefinition("CMAKE_TRY_COMPILE_OSX_ARCHITECTURES")!=0)
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
{
ENH: determine typesize by compiling a file and reading strings from the compiled output. Tested with various gcc, XCode, MSVC7, sdcc For OSX when doing TRY_COMPILE() CMAKE_OSX_ARCHITECTURES is used, if there are different results an error is generated. CMAKE_OSX_ARCHITECTURES can be overwritten for the TRY_COMPILES with CMAKE_TRY_COMPILE_OSX_ARCHITECTURES. Alex
2007-06-05 01:08:46 +04:00
std::string flag="-DCMAKE_OSX_ARCHITECTURES=";
flag += this->Makefile->GetSafeDefinition(
"CMAKE_TRY_COMPILE_OSX_ARCHITECTURES");
cmakeFlags.push_back(flag);
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
}
ENH: determine typesize by compiling a file and reading strings from the compiled output. Tested with various gcc, XCode, MSVC7, sdcc For OSX when doing TRY_COMPILE() CMAKE_OSX_ARCHITECTURES is used, if there are different results an error is generated. CMAKE_OSX_ARCHITECTURES can be overwritten for the TRY_COMPILES with CMAKE_TRY_COMPILE_OSX_ARCHITECTURES. Alex
2007-06-05 01:08:46 +04:00
else if (this->Makefile->GetDefinition("CMAKE_OSX_ARCHITECTURES")!=0)
{
std::string flag="-DCMAKE_OSX_ARCHITECTURES=";
flag += this->Makefile->GetSafeDefinition("CMAKE_OSX_ARCHITECTURES");
cmakeFlags.push_back(flag);
}
BUG: fix for #0009051 CMake does not pass CMAKE_OSX_SYSROOT and CMAKE_OSX_DEPLOYMENT_TARGET when running TRY_COMPILE
2009-05-19 19:25:28 +04:00
/* on APPLE also pass CMAKE_OSX_SYSROOT to the try_compile */
if(this->Makefile->GetDefinition("CMAKE_OSX_SYSROOT")!=0)
{
std::string flag="-DCMAKE_OSX_SYSROOT=";
flag += this->Makefile->GetSafeDefinition("CMAKE_OSX_SYSROOT");
cmakeFlags.push_back(flag);
}
/* on APPLE also pass CMAKE_OSX_DEPLOYMENT_TARGET to the try_compile */
if(this->Makefile->GetDefinition("CMAKE_OSX_DEPLOYMENT_TARGET")!=0)
{
std::string flag="-DCMAKE_OSX_DEPLOYMENT_TARGET=";
flag += this->Makefile->GetSafeDefinition("CMAKE_OSX_DEPLOYMENT_TARGET");
cmakeFlags.push_back(flag);
}
Refactor generation of shared library flags CMAKE_SHARED_LIBRARY_<lang>_FLAGS has flags on various platforms for a variety of purposes that are correlated with shared libraries but not exclusive to them. Refactor generation of these flags to use new purpose-specific platform variables CMAKE_<lang>_COMPILE_OPTIONS_DLL CMAKE_<lang>_COMPILE_OPTIONS_PIC CMAKE_<lang>_COMPILE_OPTIONS_PIE Activate the DLL flags specifically for shared libraries. Add a new POSITION_INDEPENDENT_CODE target property to activate PIC/PIE flags, and default to true for shared libraries to preserve default behavior. Initialize the new property from CMAKE_POSITION_INDEPENDENT_CODE to allow easy global configuration in projects. Although the default behavior is unchanged by this refactoring, the new approach ignores CMAKE_SHARED_LIBRARY_<lang>_FLAGS completely. We must leave it set in case projects reference the value. Furthermore, if a project modifies CMAKE_SHARED_LIBRARY_<lang>_FLAGS it expects the new value to be used. Add policy CMP0018 to handle compatibility with projects that modify this platform variable. Add a PositionIndependentCode test on platforms where we can get meaningful results.
2012-05-30 22:13:09 +04:00
if(this->Makefile->GetDefinition("CMAKE_POSITION_INDEPENDENT_CODE")!=0)
{
Generate modern-style cmake code. The commits 9db31162 (Remove CMake-language block-end command arguments, 2012-08-13) and 77543bde (Convert CMake-language commands to lower case, 2012-08-13) changed most cmake code to use lowercase commands and no parameters in termination commands. However, those changes excluded cmake code generated in c++ by cmake. Make a similar style change to code generated by cmake.
2013-08-22 13:30:19 +04:00
fprintf(fout, "set(CMAKE_POSITION_INDEPENDENT_CODE \"ON\")\n");
Refactor generation of shared library flags CMAKE_SHARED_LIBRARY_<lang>_FLAGS has flags on various platforms for a variety of purposes that are correlated with shared libraries but not exclusive to them. Refactor generation of these flags to use new purpose-specific platform variables CMAKE_<lang>_COMPILE_OPTIONS_DLL CMAKE_<lang>_COMPILE_OPTIONS_PIC CMAKE_<lang>_COMPILE_OPTIONS_PIE Activate the DLL flags specifically for shared libraries. Add a new POSITION_INDEPENDENT_CODE target property to activate PIC/PIE flags, and default to true for shared libraries to preserve default behavior. Initialize the new property from CMAKE_POSITION_INDEPENDENT_CODE to allow easy global configuration in projects. Although the default behavior is unchanged by this refactoring, the new approach ignores CMAKE_SHARED_LIBRARY_<lang>_FLAGS completely. We must leave it set in case projects reference the value. Furthermore, if a project modifies CMAKE_SHARED_LIBRARY_<lang>_FLAGS it expects the new value to be used. Add policy CMP0018 to handle compatibility with projects that modify this platform variable. Add a PositionIndependentCode test on platforms where we can get meaningful results.
2012-05-30 22:13:09 +04:00
}
ENH: determine typesize by compiling a file and reading strings from the compiled output. Tested with various gcc, XCode, MSVC7, sdcc For OSX when doing TRY_COMPILE() CMAKE_OSX_ARCHITECTURES is used, if there are different results an error is generated. CMAKE_OSX_ARCHITECTURES can be overwritten for the TRY_COMPILES with CMAKE_TRY_COMPILE_OSX_ARCHITECTURES. Alex
2007-06-05 01:08:46 +04:00
Always place try_compile executables predictably (#11724) Set CMAKE_RUNTIME_OUTPUT_DIRECTORY explicitly in try_compile projects so that the COPY_FILE feature knows where to look. This makes the feature robust against CMAKE_USER_MAKE_RULES_OVERRIDE files that set variables like CMAKE_RUNTIME_OUTPUT_DIRECTORY or EXECUTABLE_OUTPUT_PATH.
2011-01-20 16:08:47 +03:00
/* Put the executable at a known location (for COPY_FILE). */
Generate modern-style cmake code. The commits 9db31162 (Remove CMake-language block-end command arguments, 2012-08-13) and 77543bde (Convert CMake-language commands to lower case, 2012-08-13) changed most cmake code to use lowercase commands and no parameters in termination commands. However, those changes excluded cmake code generated in c++ by cmake. Make a similar style change to code generated by cmake.
2013-08-22 13:30:19 +04:00
fprintf(fout, "set(CMAKE_RUNTIME_OUTPUT_DIRECTORY \"%s\")\n",
Always place try_compile executables predictably (#11724) Set CMAKE_RUNTIME_OUTPUT_DIRECTORY explicitly in try_compile projects so that the COPY_FILE feature knows where to look. This makes the feature robust against CMAKE_USER_MAKE_RULES_OVERRIDE files that set variables like CMAKE_RUNTIME_OUTPUT_DIRECTORY or EXECUTABLE_OUTPUT_PATH.
2011-01-20 16:08:47 +03:00
this->BinaryDirectory.c_str());
/* Create the actual executable. */
Generate modern-style cmake code. The commits 9db31162 (Remove CMake-language block-end command arguments, 2012-08-13) and 77543bde (Convert CMake-language commands to lower case, 2012-08-13) changed most cmake code to use lowercase commands and no parameters in termination commands. However, those changes excluded cmake code generated in c++ by cmake. Make a similar style change to code generated by cmake.
2013-08-22 13:30:19 +04:00
fprintf(fout, "add_executable(%s", targetName);
try_compile: Add signature to allow multiple SOURCES Extend the signature try_compile(RESULT_VAR <bindir> <srcfile> ...) to allow multiple sources as try_compile(RESULT_VAR <bindir> SOURCES <srcfile>... ...) Process the sources to generate a CMakeLists.txt that enables all needed languages. Teach the TryCompile test to try cases with two sources of the same language and of mixed languages. Teach RunCMake.try_compile to cover error cases for the signature.
2013-06-06 21:54:44 +04:00
for(std::vector<std::string>::iterator si = sources.begin();
si != sources.end(); ++si)
{
fprintf(fout, " \"%s\"", si->c_str());
// Add dependencies on any non-temporary sources.
if(si->find("CMakeTmp") == si->npos)
{
cmMakefile: Refactor AddCMakeDependFile and AddCMakeOutputFile. AddCMakeDependFile and AddCMakeOutputFile both store as std::string and all calling sites use std::string. So instead of creating more temporary objects, lets just use std::strings.
2013-06-18 21:41:50 +04:00
this->Makefile->AddCMakeDependFile(*si);
try_compile: Add signature to allow multiple SOURCES Extend the signature try_compile(RESULT_VAR <bindir> <srcfile> ...) to allow multiple sources as try_compile(RESULT_VAR <bindir> SOURCES <srcfile>... ...) Process the sources to generate a CMakeLists.txt that enables all needed languages. Teach the TryCompile test to try cases with two sources of the same language and of mixed languages. Teach RunCMake.try_compile to cover error cases for the signature.
2013-06-06 21:54:44 +04:00
}
}
fprintf(fout, ")\n");
Handle targets in the LINK_LIBRARIES of try_compile. Imported targets are re-exported so that they can be used by the try_compile generated code with target_link_libraries. This makes the use of the cmake_expand_imported_targets macro obsolete. The macro is not able to expand the generator expressions which may appear in the IMPORTED_LINK_INTERFACE_LIBRARIES content. Instead it just sees them as 'not a target'.
2013-02-09 13:34:37 +04:00
if (useOldLinkLibs)
{
fprintf(fout,
Generate modern-style cmake code. The commits 9db31162 (Remove CMake-language block-end command arguments, 2012-08-13) and 77543bde (Convert CMake-language commands to lower case, 2012-08-13) changed most cmake code to use lowercase commands and no parameters in termination commands. However, those changes excluded cmake code generated in c++ by cmake. Make a similar style change to code generated by cmake.
2013-08-22 13:30:19 +04:00
"target_link_libraries(%s ${LINK_LIBRARIES})\n",targetName);
Handle targets in the LINK_LIBRARIES of try_compile. Imported targets are re-exported so that they can be used by the try_compile generated code with target_link_libraries. This makes the use of the cmake_expand_imported_targets macro obsolete. The macro is not able to expand the generator expressions which may appear in the IMPORTED_LINK_INTERFACE_LIBRARIES content. Instead it just sees them as 'not a target'.
2013-02-09 13:34:37 +04:00
}
else
{
Generate modern-style cmake code. The commits 9db31162 (Remove CMake-language block-end command arguments, 2012-08-13) and 77543bde (Convert CMake-language commands to lower case, 2012-08-13) changed most cmake code to use lowercase commands and no parameters in termination commands. However, those changes excluded cmake code generated in c++ by cmake. Make a similar style change to code generated by cmake.
2013-08-22 13:30:19 +04:00
fprintf(fout, "target_link_libraries(%s %s)\n",
Handle targets in the LINK_LIBRARIES of try_compile. Imported targets are re-exported so that they can be used by the try_compile generated code with target_link_libraries. This makes the use of the cmake_expand_imported_targets macro obsolete. The macro is not able to expand the generator expressions which may appear in the IMPORTED_LINK_INTERFACE_LIBRARIES content. Instead it just sees them as 'not a target'.
2013-02-09 13:34:37 +04:00
targetName,
libsToLink.c_str());
}
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
fclose(fout);
projectName = "CMAKE_TRY_COMPILE";
}
Remove trailing whitespace Alex
2011-09-15 18:20:33 +04:00
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
bool erroroc = cmSystemTools::GetErrorOccuredFlag();
cmSystemTools::ResetErrorOccuredFlag();
std::string output;
// actually do the try compile now that everything is setup
Remove trailing whitespace Alex
2011-09-15 18:20:33 +04:00
int res = this->Makefile->TryCompile(sourceDirectory,
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
this->BinaryDirectory.c_str(),
Remove trailing whitespace Alex
2011-09-15 18:20:33 +04:00
projectName,
targetName,
No /fast targets in try_compile project mode 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.
2009-08-04 22:37:46 +04:00
this->SrcFileSignature,
Remove trailing whitespace Alex
2011-09-15 18:20:33 +04:00
&cmakeFlags,
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
&output);
if ( erroroc )
{
cmSystemTools::SetErrorOccured();
}
Remove trailing whitespace Alex
2011-09-15 18:20:33 +04:00
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
// set the result var to the return value to indicate success or failure
this->Makefile->AddCacheDefinition(argv[0].c_str(),
(res == 0 ? "TRUE" : "FALSE"),
"Result of TRY_COMPILE",
cmCacheManager::INTERNAL);
if ( outputVariable.size() > 0 )
{
this->Makefile->AddDefinition(outputVariable.c_str(), output.c_str());
}
Remove trailing whitespace Alex
2011-09-15 18:20:33 +04:00
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
if (this->SrcFileSignature)
{
try_compile: Add COPY_FILE_ERROR option to capture failure When the COPY_FILE operation fails optionally capture the error message with a COPY_FILE_ERROR option instead of reporting the error immediately. This gives callers a chance to do something else or report the error. Teach the RunCMake.try_compile test to cover bad argument combinations involving COPY_FILE_ERROR. Teach the TryCompile test to cover the case of a COPY_FILE error message captured by COPY_FILE_ERROR.
2013-07-09 23:26:15 +04:00
std::string copyFileErrorMessage;
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
this->FindOutputFile(targetName);
ENH: Emit a little more information in the error message when the output file is not found during a core try compile.
2009-01-29 23:23:18 +03:00
ENH: add COPY_FILE argument to TRY_COMPILE, so the compiled executable can be used e.g. for getting strings out of it. Alex
2007-05-24 20:06:59 +04:00
if ((res==0) && (copyFile.size()))
{
Fix try_compile when file cannot be found The try_compile() command's COPY_FILE option should not try to actually copy the file if it cannot be found. Some C runtime library's fopen cannot handle an empty file name.
2009-10-28 18:24:08 +03:00
if(this->OutputFile.empty() ||
!cmSystemTools::CopyFileAlways(this->OutputFile.c_str(),
ENH: add COPY_FILE argument to TRY_COMPILE, so the compiled executable can be used e.g. for getting strings out of it. Alex
2007-05-24 20:06:59 +04:00
copyFile.c_str()))
{
STYLE: Emit filenames in try_compile error message to get more information from the Continuous dashboard test that is failing.
2009-01-27 19:35:36 +03:00
cmOStringStream emsg;
Improve try_compile and try_run error messages Use IssueMessage to give the messages context and better formatting.
2011-01-20 16:58:49 +03:00
emsg << "Cannot copy output executable\n"
<< " '" << this->OutputFile.c_str() << "'\n"
<< "to destination specified by COPY_FILE:\n"
<< " '" << copyFile.c_str() << "'\n";
if(!this->FindErrorMessage.empty())
ENH: Emit a little more information in the error message when the output file is not found during a core try compile.
2009-01-29 23:23:18 +03:00
{
Improve try_compile and try_run error messages Use IssueMessage to give the messages context and better formatting.
2011-01-20 16:58:49 +03:00
emsg << this->FindErrorMessage.c_str();
ENH: Emit a little more information in the error message when the output file is not found during a core try compile.
2009-01-29 23:23:18 +03:00
}
try_compile: Add COPY_FILE_ERROR option to capture failure When the COPY_FILE operation fails optionally capture the error message with a COPY_FILE_ERROR option instead of reporting the error immediately. This gives callers a chance to do something else or report the error. Teach the RunCMake.try_compile test to cover bad argument combinations involving COPY_FILE_ERROR. Teach the TryCompile test to cover the case of a COPY_FILE error message captured by COPY_FILE_ERROR.
2013-07-09 23:26:15 +04:00
if(copyFileError.empty())
{
this->Makefile->IssueMessage(cmake::FATAL_ERROR, emsg.str());
return -1;
}
else
{
copyFileErrorMessage = emsg.str();
}
ENH: add COPY_FILE argument to TRY_COMPILE, so the compiled executable can be used e.g. for getting strings out of it. Alex
2007-05-24 20:06:59 +04:00
}
}
try_compile: Add COPY_FILE_ERROR option to capture failure When the COPY_FILE operation fails optionally capture the error message with a COPY_FILE_ERROR option instead of reporting the error immediately. This gives callers a chance to do something else or report the error. Teach the RunCMake.try_compile test to cover bad argument combinations involving COPY_FILE_ERROR. Teach the TryCompile test to cover the case of a COPY_FILE error message captured by COPY_FILE_ERROR.
2013-07-09 23:26:15 +04:00
if(!copyFileError.empty())
{
this->Makefile->AddDefinition(copyFileError.c_str(),
copyFileErrorMessage.c_str());
}
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
}
return res;
}
void cmCoreTryCompile::CleanupFiles(const char* binDir)
{
if ( !binDir )
{
return;
}
Remove trailing whitespace Alex
2011-09-15 18:20:33 +04:00
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
std::string bdir = binDir;
if(bdir.find("CMakeTmp") == std::string::npos)
{
cmSystemTools::Error(
"TRY_COMPILE attempt to remove -rf directory that does not contain "
"CMakeTmp:", binDir);
return;
}
Remove trailing whitespace Alex
2011-09-15 18:20:33 +04:00
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
cmsys::Directory dir;
dir.Load(binDir);
size_t fileNum;
std::set<cmStdString> deletedFiles;
for (fileNum = 0; fileNum < dir.GetNumberOfFiles(); ++fileNum)
{
if (strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)),".") &&
strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)),".."))
{
Remove trailing whitespace Alex
2011-09-15 18:20:33 +04:00
if(deletedFiles.find( dir.GetFile(static_cast<unsigned long>(fileNum)))
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
== deletedFiles.end())
{
deletedFiles.insert(dir.GetFile(static_cast<unsigned long>(fileNum)));
std::string fullPath = binDir;
fullPath += "/";
fullPath += dir.GetFile(static_cast<unsigned long>(fileNum));
if(cmSystemTools::FileIsDirectory(fullPath.c_str()))
{
this->CleanupFiles(fullPath.c_str());
try_compile: Cleanup temporary directories (#13160) Since commit 4fbdce2b (try_compile: Use random executable file name, 2012-02-13) a different <target>.dir is used for each try-compile. Cleanup the directories as well as their content to avoid accumulating leftover temporary directories.
2012-04-26 16:18:51 +04:00
cmSystemTools::RemoveADirectory(fullPath.c_str());
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
}
else
{
Fix try_compile RemoveFile anti-virus loop (#11503) Commit 3827991e (...fix...not being able to remove try compile code, 2008-03-26) introduced a loop of RemoveFile attempts to overcome anti-virus locks on recently created try_compile executables. Fix the logic in this loop to work when the file is already missing.
2010-12-03 15:38:15 +03:00
// Sometimes anti-virus software hangs on to new files so we
// cannot delete them immediately. Try a few times.
int tries = 5;
while(!cmSystemTools::RemoveFile(fullPath.c_str()) &&
--tries && cmSystemTools::FileExists(fullPath.c_str()))
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
{
Fix try_compile RemoveFile anti-virus loop (#11503) Commit 3827991e (...fix...not being able to remove try compile code, 2008-03-26) introduced a loop of RemoveFile attempts to overcome anti-virus locks on recently created try_compile executables. Fix the logic in this loop to work when the file is already missing.
2010-12-03 15:38:15 +03:00
cmSystemTools::Delay(500);
}
if(tries == 0)
{
std::string m = "Remove failed on file: " + fullPath;
cmSystemTools::ReportLastSystemError(m.c_str());
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
}
}
}
}
}
}
void cmCoreTryCompile::FindOutputFile(const char* targetName)
{
this->FindErrorMessage = "";
this->OutputFile = "";
std::string tmpOutputFile = "/";
tmpOutputFile += targetName;
tmpOutputFile +=this->Makefile->GetSafeDefinition("CMAKE_EXECUTABLE_SUFFIX");
// a list of directories where to search for the compilation result
// at first directly in the binary dir
std::vector<std::string> searchDirs;
searchDirs.push_back("");
const char* config = this->Makefile->GetDefinition(
"CMAKE_TRY_COMPILE_CONFIGURATION");
// if a config was specified try that first
if (config && config[0])
{
std::string tmp = "/";
tmp += config;
searchDirs.push_back(tmp);
}
searchDirs.push_back("/Debug");
searchDirs.push_back("/Development");
for(std::vector<std::string>::const_iterator it = searchDirs.begin();
it != searchDirs.end();
++it)
{
std::string command = this->BinaryDirectory;
command += *it;
command += tmpOutputFile;
if(cmSystemTools::FileExists(command.c_str()))
{
tmpOutputFile = cmSystemTools::CollapseFullPath(command.c_str());
this->OutputFile = tmpOutputFile;
return;
}
}
cmOStringStream emsg;
Improve try_compile and try_run error messages Use IssueMessage to give the messages context and better formatting.
2011-01-20 16:58:49 +03:00
emsg << "Unable to find the executable at any of:\n";
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
for (unsigned int i = 0; i < searchDirs.size(); ++i)
{
Improve try_compile and try_run error messages Use IssueMessage to give the messages context and better formatting.
2011-01-20 16:58:49 +03:00
emsg << " " << this->BinaryDirectory << searchDirs[i]
<< tmpOutputFile << "\n";
ENH: add two simple tests for TRY_RUN() STYLE: create a new base class cmCoreTryCompile, from which cmTryCompileCommand and cmTryRunCommand are derived, so there are no public static functions with lots of arguments anymore Alex
2007-05-24 19:27:51 +04:00
}
this->FindErrorMessage = emsg.str();
return;
}