kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

updated to try compile

This commit is contained in:
Ken Martin 2002-09-19 09:49:14 -04:00
parent 3eaf054d6a
commit d4f5545007
3 changed files with 97 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/cmCommands.cxx
View File

@ -77,6 +77,7 @@
#include "cmSubdirDependsCommand.cxx"
#include "cmTargetLinkLibrariesCommand.cxx"
#include "cmTryCompileCommand.cxx"
#include "cmTryRunCommand.cxx"
#include "cmUseMangledMesaCommand.cxx"
#include "cmUtilitySourceCommand.cxx"
#include "cmVariableRequiresCommand.cxx"
@ -159,6 +160,7 @@ void GetPredefinedCommands(std::list<cmCommand*>& commands)
commands.push_back(new cmSubdirDependsCommand);
commands.push_back(new cmTargetLinkLibrariesCommand);
commands.push_back(new cmTryCompileCommand);
commands.push_back(new cmTryRunCommand);
commands.push_back(new cmUseMangledMesaCommand);
commands.push_back(new cmUtilitySourceCommand);
commands.push_back(new cmVariableRequiresCommand);

117
Source/cmTryCompileCommand.cxx
View File

@ -17,34 +17,12 @@
#include "cmTryCompileCommand.h"
#include "cmCacheManager.h"
// cmExecutableCommand
bool cmTryCompileCommand::InitialPass(std::vector<std::string> const& argv)
int cmTryCompileCommand::CoreTryCompileCode(
cmMakefile *mf, std::vector<std::string> const& argv, bool clean)
{
if(argv.size() < 3)
{
return false;
}
// which signature were we called with ?
bool srcFileSignature = true;
// look for CMAKE_FLAGS and store them
std::vector<std::string> cmakeFlags;
int i;
for (i = 3; i < argv.size(); ++i)
{
if (argv[i] == "CMAKE_FLAGS")
{
for (; i < argv.size(); ++i)
{
cmakeFlags.push_back(argv[i]);
}
}
else
{
srcFileSignature = false;
}
}
// where will the binaries be stored
const char* binaryDirectory = argv[1].c_str();
@ -52,7 +30,7 @@ bool cmTryCompileCommand::InitialPass(std::vector<std::string> const& argv)
const char* projectName = 0;
const char* targetName = 0;
std::string tmpString;
// compute the binary dir when TRY_COMPILE is called with a src file
// signature
if (srcFileSignature)
@ -64,13 +42,54 @@ bool cmTryCompileCommand::InitialPass(std::vector<std::string> const& argv)
cmSystemTools::MakeDirectory(binaryDirectory);
// do not allow recursive try Compiles
if (!strcmp(binaryDirectory,m_Makefile->GetHomeOutputDirectory()))
if (!strcmp(binaryDirectory,mf->GetHomeOutputDirectory()))
{
cmSystemTools::Error("Attempt at a recursive or nested TRY_COMPILE",
binaryDirectory);
return false;
return -1;
}
// look for CMAKE_FLAGS and store them
std::vector<std::string> cmakeFlags;
for (i = 3; i < argv.size(); ++i)
{
if (argv[i] == "CMAKE_FLAGS")
{
for (; i < argv.size() && argv[i] != "COMPILE_DEFINITIONS";
++i)
{
cmakeFlags.push_back(argv[i]);
}
break;
}
else
{
srcFileSignature = false;
}
}
// look for COMPILE_DEFINITIONS and store them
std::vector<std::string> compileFlags;
for (i = 0; i < argv.size(); ++i)
{
if (argv[i] == "COMPILE_DEFINITIONS")
{
// only valid for srcfile signatures
if (!srcFileSignature)
{
cmSystemTools::Error(
"COMPILE_FLAGS specified on a srcdir type TRY_COMPILE");
return -1;
}
for (i = i + 1; i < argv.size() && argv[i] != "CMAKE_FLAGS";
++i)
{
compileFlags.push_back(argv[i]);
}
break;
}
}
// which signature are we using? If we are using var srcfile bindir
if (srcFileSignature)
{
@ -89,13 +108,24 @@ bool cmTryCompileCommand::InitialPass(std::vector<std::string> const& argv)
{
cmSystemTools::Error("Failed to create CMakeList file for ",
outFileName.c_str());
return false;
return -1;
}
fprintf(fout,"PROJECT(CMAKE_TRY_COMPILE)\n");
fprintf(fout, "PROJECT(CMAKE_TRY_COMPILE)\n");
fprintf(fout, "IF (CMAKE_ANSI_CXXFLAGS)\n");
fprintf(fout, " SET(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} ${CMAKE_ANSI_CXXFLAGS}\")\n");
fprintf(fout, "ENDIF (CMAKE_ANSI_CXXFLAGS)\n");
fprintf(fout,"ADD_EXECUTABLE(cmTryCompileExec \"%s\")\n",argv[2].c_str());
// handle any compile flags we need to pass on
if (compileFlags.size())
{
fprintf(fout, "ADD_DEFINITIONS( ");
for (i = 0; i < compileFlags.size(); ++i)
{
fprintf(fout,"%s ",compileFlags[i].c_str());
}
fprintf(fout, ")\n");
}
fprintf(fout, "ADD_EXECUTABLE(cmTryCompileExec \"%s\")\n",argv[2].c_str());
fclose(fout);
projectName = "CMAKE_TRY_COMPILE";
targetName = "cmTryCompileExec";
@ -112,14 +142,14 @@ bool cmTryCompileCommand::InitialPass(std::vector<std::string> const& argv)
}
// actually do the try compile now that everything is setup
int res = m_Makefile->TryCompile(sourceDirectory, binaryDirectory,
projectName, targetName, &cmakeFlags);
int res = mf->TryCompile(sourceDirectory, binaryDirectory,
projectName, targetName, &cmakeFlags);
// set the result var to the return value to indicate success or failure
m_Makefile->AddDefinition(argv[0].c_str(), (res == 0 ? "TRUE" : "FALSE"));
// if we created a directory etc, then cleanup after ourselves
if (srcFileSignature)
mf->AddDefinition(argv[0].c_str(), (res == 0 ? "TRUE" : "FALSE"));
// if They specified clean then we clean up what we can
if (srcFileSignature && clean)
{
cmDirectory dir;
dir.Load(binaryDirectory);
@ -137,6 +167,19 @@ bool cmTryCompileCommand::InitialPass(std::vector<std::string> const& argv)
}
}
return res;
}
// cmExecutableCommand
bool cmTryCompileCommand::InitialPass(std::vector<std::string> const& argv)
{
if(argv.size() < 3)
{
return false;
}
cmTryCompileCommand::CoreTryCompileCode(m_Makefile,argv,true);
return true;
}

18
Source/cmTryCompileCommand.h
View File

@ -54,8 +54,15 @@ public:
{
return "Try compiling some code";
}
/**
* This is the core code for try compile. It is here so that other
* commands, such as TryRun can access the same logic without
* dumplication.
*/
static int CoreTryCompileCode(
cmMakefile *mf, std::vector<std::string> const& argv, bool clean);
/**
* More documentation.
*/
@ -66,8 +73,13 @@ public:
"Try compiling a program. Return the success or failure in RESULT_VAR "
"If <target name> is specified then build just that target "
"otherwise the all or ALL_BUILD target is built.\n"
"TRY_COMPILE(RESULT_VAR bindir srcfile <CMAKE_FLAGS <Flags>>)\n"
"Try compiling a srcfile. Return the success or failure in RESULT_VAR.";
"TRY_COMPILE(RESULT_VAR bindir srcfile\n"
" <CMAKE_FLAGS <Flags>> <COMPILE_DEFINITIONS <flags> ...>)\n"
"Try compiling a srcfile. Return the success or failure in RESULT_VAR. "
"CMAKE_FLAGS can be used to pass -DVAR:TYPE=VALUE flags to cmake. The "
"COMPILE_DEFINITIONS are -Ddefinition that will be passed to the "
"compile line. If srcfile is specified the files in bindir/CMakeTmp "
"are cleaned.";
}
cmTypeMacro(cmTryCompileCommand, cmCommand);