CMake/Source/cmake.cxx

624 lines
19 KiB
C++
Raw Normal View History

2001-05-18 23:25:08 +04:00
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile$
Language: C++
Date: $Date$
Version: $Revision$
2002-01-21 23:30:43 +03:00
Copyright (c) 2002 Insight Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
2001-05-18 23:25:08 +04:00
2002-01-21 23:30:43 +03:00
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
2001-05-18 23:25:08 +04:00
=========================================================================*/
#include "cmake.h"
2002-06-03 21:08:52 +04:00
#include "time.h"
2001-05-18 23:25:08 +04:00
#include "cmCacheManager.h"
// include the generator
#if defined(_WIN32) && !defined(__CYGWIN__)
#include "cmMSProjectGenerator.h"
2002-02-18 22:36:04 +03:00
#include "cmMSDotNETGenerator.h"
2001-09-07 01:28:24 +04:00
#include "cmBorlandMakefileGenerator.h"
2001-11-15 02:12:22 +03:00
#include "cmNMakeMakefileGenerator.h"
2001-05-18 23:25:08 +04:00
#else
#include "cmUnixMakefileGenerator.h"
2001-05-21 17:50:24 +04:00
#endif
2001-09-07 01:28:24 +04:00
cmake::cmake()
{
m_Verbose = false;
#if defined(_WIN32) && !defined(__CYGWIN__)
cmMakefileGenerator::RegisterGenerator(new cmMSProjectGenerator);
2002-02-18 22:36:04 +03:00
cmMakefileGenerator::RegisterGenerator(new cmMSDotNETGenerator);
2001-11-15 17:55:50 +03:00
cmMakefileGenerator::RegisterGenerator(new cmNMakeMakefileGenerator);
2001-09-07 01:28:24 +04:00
cmMakefileGenerator::RegisterGenerator(new cmBorlandMakefileGenerator);
#else
cmMakefileGenerator::RegisterGenerator(new cmUnixMakefileGenerator);
#endif
}
2001-05-18 23:25:08 +04:00
void cmake::Usage(const char* program)
{
std::strstream errorStream;
errorStream << "cmake version " << cmMakefile::GetMajorVersion()
<< "." << cmMakefile::GetMinorVersion() << "\n";
errorStream << "Usage: " << program << " [srcdir] [options]\n"
2001-12-04 01:00:43 +03:00
<< "Where cmake is run from the directory where you want the object files written. If srcdir is not specified, the current directory is used for both source and object files.\n";
errorStream << "Options are:\n";
errorStream << "\n-i (puts cmake in wizard mode, not available for ccmake)\n";
errorStream << "\n-DVAR:TYPE=VALUE (create a cache file entry)\n";
errorStream << "\n-Cpath_to_initial_cache (a cmake list file that is used to pre-load the cache with values.)\n";
errorStream << "\n[-GgeneratorName] (where generator name can be one of these: ";
2001-09-07 01:28:24 +04:00
std::vector<std::string> names;
cmMakefileGenerator::GetRegisteredGenerators(names);
for(std::vector<std::string>::iterator i =names.begin();
i != names.end(); ++i)
{
errorStream << "\"" << i->c_str() << "\" ";
2001-09-07 01:28:24 +04:00
}
2002-02-06 20:14:03 +03:00
errorStream << ")\n" << std::ends;
cmSystemTools::Error(errorStream.str());
2001-05-18 23:25:08 +04:00
}
// Parse the args
2001-12-04 01:00:43 +03:00
void cmake::SetCacheArgs(cmMakefile& builder,
const std::vector<std::string>& args)
{
for(unsigned int i=1; i < args.size(); ++i)
{
std::string arg = args[i];
if(arg.find("-D",0) == 0)
{
std::string entry = arg.substr(2);
std::string var, value;
cmCacheManager::CacheEntryType type;
if(cmCacheManager::ParseEntry(entry.c_str(), var, value, type))
{
cmCacheManager::GetInstance()->AddCacheEntry(
var.c_str(),
value.c_str(),
"No help, variable specified on the command line.",
type);
}
else
{
std::cerr << "Parse error in command line argument: " << arg << "\n"
<< "Should be: VAR:type=value\n";
}
}
2001-12-04 01:00:43 +03:00
else if(arg.find("-C",0) == 0)
{
std::string path = arg.substr(2);
std::cerr << "loading initial cache file " << path.c_str() << "\n";
if(!builder.ReadListFile(path.c_str()))
{
std::cerr << "Error in reading cmake initial cache file:"
<< path.c_str() << "\n";
}
}
}
}
2001-05-18 23:25:08 +04:00
// Parse the args
2001-05-30 23:28:55 +04:00
void cmake::SetArgs(cmMakefile& builder, const std::vector<std::string>& args)
2001-05-18 23:25:08 +04:00
{
m_Local = false;
2001-09-07 01:28:24 +04:00
bool directoriesSet = false;
// watch for cmake and cmake srcdir invocations
if (args.size() <= 2)
{
directoriesSet = true;
builder.SetHomeOutputDirectory
(cmSystemTools::GetCurrentWorkingDirectory().c_str());
builder.SetStartOutputDirectory
(cmSystemTools::GetCurrentWorkingDirectory().c_str());
if (args.size() == 2)
{
builder.SetHomeDirectory
(cmSystemTools::CollapseFullPath(args[1].c_str()).c_str());
builder.SetStartDirectory
(cmSystemTools::CollapseFullPath(args[1].c_str()).c_str());
}
else
{
builder.SetHomeDirectory
(cmSystemTools::GetCurrentWorkingDirectory().c_str());
builder.SetStartDirectory
(cmSystemTools::GetCurrentWorkingDirectory().c_str());
}
}
2001-05-18 23:25:08 +04:00
2001-06-12 16:30:12 +04:00
for(unsigned int i=1; i < args.size(); ++i)
2001-05-18 23:25:08 +04:00
{
2001-05-30 23:28:55 +04:00
std::string arg = args[i];
2001-07-02 22:38:39 +04:00
if(arg.find("-H",0) == 0)
2001-05-18 23:25:08 +04:00
{
2001-09-07 01:28:24 +04:00
directoriesSet = true;
2001-05-18 23:25:08 +04:00
std::string path = arg.substr(2);
builder.SetHomeDirectory(path.c_str());
}
2001-09-07 01:28:24 +04:00
else if(arg.find("-S",0) == 0)
2001-05-18 23:25:08 +04:00
{
2001-09-07 01:28:24 +04:00
directoriesSet = true;
2001-05-18 23:25:08 +04:00
m_Local = true;
std::string path = arg.substr(2);
builder.SetStartDirectory(path.c_str());
}
2001-09-07 01:28:24 +04:00
else if(arg.find("-O",0) == 0)
2001-05-18 23:25:08 +04:00
{
2001-09-07 01:28:24 +04:00
directoriesSet = true;
2001-05-18 23:25:08 +04:00
std::string path = arg.substr(2);
builder.SetStartOutputDirectory(path.c_str());
}
2001-09-07 01:28:24 +04:00
else if(arg.find("-B",0) == 0)
2001-05-18 23:25:08 +04:00
{
2001-09-07 01:28:24 +04:00
directoriesSet = true;
2001-05-18 23:25:08 +04:00
std::string path = arg.substr(2);
builder.SetHomeOutputDirectory(path.c_str());
}
2001-09-07 01:28:24 +04:00
else if(arg.find("-V",0) == 0)
2001-05-18 23:25:08 +04:00
{
m_Verbose = true;
}
2001-11-21 16:47:37 +03:00
else if(arg.find("-D",0) == 0)
{
// skip for now
}
2001-12-04 01:00:43 +03:00
else if(arg.find("-C",0) == 0)
{
// skip for now
}
2001-09-07 01:28:24 +04:00
else if(arg.find("-G",0) == 0)
{
std::string value = arg.substr(2);
cmMakefileGenerator* gen =
cmMakefileGenerator::CreateGenerator(value.c_str());
if(!gen)
{
cmSystemTools::Error("Could not create named generator ",
value.c_str());
}
else
{
builder.SetMakefileGenerator(gen);
}
}
// no option assume it is the path to the source
2001-09-07 01:28:24 +04:00
else
{
directoriesSet = true;
builder.SetHomeOutputDirectory
(cmSystemTools::GetCurrentWorkingDirectory().c_str());
builder.SetStartOutputDirectory
(cmSystemTools::GetCurrentWorkingDirectory().c_str());
builder.SetHomeDirectory
(cmSystemTools::CollapseFullPath(arg.c_str()).c_str());
builder.SetStartDirectory
(cmSystemTools::CollapseFullPath(arg.c_str()).c_str());
2001-09-07 01:28:24 +04:00
}
}
if(!directoriesSet)
{
builder.SetHomeOutputDirectory
(cmSystemTools::GetCurrentWorkingDirectory().c_str());
builder.SetStartOutputDirectory
(cmSystemTools::GetCurrentWorkingDirectory().c_str());
builder.SetHomeDirectory
(cmSystemTools::GetCurrentWorkingDirectory().c_str());
builder.SetStartDirectory
(cmSystemTools::GetCurrentWorkingDirectory().c_str());
2001-05-18 23:25:08 +04:00
}
2001-05-21 17:32:11 +04:00
if (!m_Local)
{
builder.SetStartDirectory(builder.GetHomeDirectory());
builder.SetStartOutputDirectory(builder.GetHomeOutputDirectory());
}
2001-05-18 23:25:08 +04:00
}
// at the end of this CMAKE_ROOT and CMAKE_COMMAND should be added to the cache
2001-05-30 23:28:55 +04:00
void cmake::AddCMakePaths(const std::vector<std::string>& args)
2001-05-18 23:25:08 +04:00
{
// Find our own executable.
2001-05-30 23:28:55 +04:00
std::string cMakeSelf = args[0];
2001-05-24 00:28:34 +04:00
cmSystemTools::ConvertToUnixSlashes(cMakeSelf);
cMakeSelf = cmSystemTools::FindProgram(cMakeSelf.c_str());
if(!cmSystemTools::FileExists(cMakeSelf.c_str()))
{
#ifdef CMAKE_BUILD_DIR
2002-06-03 21:08:52 +04:00
std::string intdir = ".";
#ifdef CMAKE_INTDIR
intdir = CMAKE_INTDIR;
#endif
cMakeSelf = CMAKE_BUILD_DIR;
cMakeSelf += "/Source/";
cMakeSelf += intdir;
cMakeSelf += "/cmake";
cMakeSelf += cmSystemTools::GetExecutableExtension();
#endif
}
#ifdef CMAKE_PREFIX
2001-06-22 01:41:23 +04:00
if(!cmSystemTools::FileExists(cMakeSelf.c_str()))
{
cMakeSelf = CMAKE_PREFIX "/bin/cmake";
}
#endif
2001-06-22 01:41:23 +04:00
if(!cmSystemTools::FileExists(cMakeSelf.c_str()))
{
cmSystemTools::Error("CMAKE can not find the command line program cmake. "
"Attempted path: ", cMakeSelf.c_str());
return;
}
// Save the value in the cache
2001-05-23 23:49:18 +04:00
cmCacheManager::GetInstance()->AddCacheEntry
("CMAKE_COMMAND",cMakeSelf.c_str(), "Path to CMake executable.",
2001-05-23 23:49:18 +04:00
cmCacheManager::INTERNAL);
// Find and save the command to edit the cache
std::string editCacheCommand = cmSystemTools::GetFilenamePath(cMakeSelf) +
"/ccmake" + cmSystemTools::GetFilenameExtension(cMakeSelf);
if( !cmSystemTools::FileExists(editCacheCommand.c_str()))
{
editCacheCommand = cmSystemTools::GetFilenamePath(cMakeSelf) +
"/CMakeSetup" + cmSystemTools::GetFilenameExtension(cMakeSelf);
}
if(cmSystemTools::FileExists(editCacheCommand.c_str()))
{
cmCacheManager::GetInstance()->AddCacheEntry
("CMAKE_EDIT_COMMAND", editCacheCommand.c_str(),
"Path to cache edit program executable.", cmCacheManager::INTERNAL);
}
2001-05-18 23:25:08 +04:00
// do CMAKE_ROOT, look for the environment variable first
std::string cMakeRoot;
std::string modules;
2001-05-18 23:25:08 +04:00
if (getenv("CMAKE_ROOT"))
{
cMakeRoot = getenv("CMAKE_ROOT");
modules = cMakeRoot + "/Modules/FindVTK.cmake";
2001-05-18 23:25:08 +04:00
}
if(!cmSystemTools::FileExists(modules.c_str()))
2001-05-18 23:25:08 +04:00
{
// next try exe/..
cMakeRoot = cmSystemTools::GetProgramPath(cMakeSelf.c_str());
std::string::size_type slashPos = cMakeRoot.rfind("/");
if(slashPos != std::string::npos)
{
cMakeRoot = cMakeRoot.substr(0, slashPos);
}
// is there no Modules direcory there?
2001-06-22 01:41:23 +04:00
modules = cMakeRoot + "/Modules/FindVTK.cmake";
}
2001-06-22 01:41:23 +04:00
if (!cmSystemTools::FileExists(modules.c_str()))
{
// try exe/../share/cmake
cMakeRoot += "/share/CMake";
modules = cMakeRoot + "/Modules/FindVTK.cmake";
}
#ifdef CMAKE_ROOT_DIR
2001-06-22 01:41:23 +04:00
if (!cmSystemTools::FileExists(modules.c_str()))
{
2001-06-22 01:25:35 +04:00
// try compiled in root directory
cMakeRoot = CMAKE_ROOT_DIR;
modules = cMakeRoot + "/Modules/FindVTK.cmake";
}
2001-05-18 23:25:08 +04:00
#endif
#ifdef CMAKE_PREFIX
2001-06-22 01:41:23 +04:00
if (!cmSystemTools::FileExists(modules.c_str()))
{
2001-06-22 01:25:35 +04:00
// try compiled in install prefix
cMakeRoot = CMAKE_PREFIX "/share/CMake";
modules = cMakeRoot + "/Modules/FindVTK.cmake";
}
#endif
2001-06-22 01:41:23 +04:00
if (!cmSystemTools::FileExists(modules.c_str()))
{
2001-06-22 01:25:35 +04:00
// try
cMakeRoot = cmSystemTools::GetProgramPath(cMakeSelf.c_str());
cMakeRoot += "/share/CMake";
modules = cMakeRoot + "/Modules/FindVTK.cmake";
}
if(!cmSystemTools::FileExists(modules.c_str()))
{
// next try exe
cMakeRoot = cmSystemTools::GetProgramPath(cMakeSelf.c_str());
// is there no Modules direcory there?
modules = cMakeRoot + "/Modules/FindVTK.cmake";
}
2001-06-22 01:41:23 +04:00
if (!cmSystemTools::FileExists(modules.c_str()))
{
// couldn't find modules
cmSystemTools::Error("Could not find CMAKE_ROOT !!!\n",
"Modules directory not in directory:\n",
modules.c_str());
return;
2001-05-18 23:25:08 +04:00
}
cmCacheManager::GetInstance()->AddCacheEntry
("CMAKE_ROOT", cMakeRoot.c_str(),
"Path to CMake installation.", cmCacheManager::INTERNAL);
}
int cmake::Generate(const std::vector<std::string>& args, bool buildMakefiles)
2001-05-18 23:25:08 +04:00
{
2002-05-23 18:33:37 +04:00
if(args.size() == 1 && !cmSystemTools::FileExists("CMakeLists.txt"))
{
this->Usage(args[0].c_str());
return -1;
}
2001-06-27 19:35:08 +04:00
// look for obvious request for help
for(unsigned int i=1; i < args.size(); ++i)
{
std::string arg = args[i];
if(arg.find("-help",0) != std::string::npos ||
arg.find("--help",0) != std::string::npos ||
arg.find("/?",0) != std::string::npos ||
arg.find("-usage",0) != std::string::npos)
{
this->Usage(args[0].c_str());
return -1;
}
}
2001-05-18 23:25:08 +04:00
// Create a makefile
cmMakefile mf;
2001-09-07 01:28:24 +04:00
// extract the directory arguments, could create a Generator
this->SetArgs(mf, args);
// Read and parse the input makefile
mf.MakeStartDirectoriesCurrent();
cmCacheManager::GetInstance()->LoadCache(&mf);
2002-04-18 22:51:33 +04:00
if(mf.GetDefinition("CMAKE_HOME_DIRECTORY"))
{
std::string cacheStart = mf.GetDefinition("CMAKE_HOME_DIRECTORY");
cacheStart += "/CMakeLists.txt";
std::string currentStart = mf.GetHomeDirectory();
currentStart += "/CMakeLists.txt";
if(!cmSystemTools::SameFile(cacheStart.c_str(), currentStart.c_str()))
{
std::string message = "Error: source : ";
message += currentStart;
message += "\nDoes not match source used to generate cache: ";
message += cacheStart;
message += "\nRe-run cmake with a different source directory.";
cmSystemTools::Error(message.c_str());
2002-04-24 00:16:48 +04:00
return -2;
}
}
2002-04-18 22:51:33 +04:00
mf.AddCacheDefinition("CMAKE_HOME_DIRECTORY", mf.GetHomeDirectory(),
"Start directory with the top level CMakeLists.txt file for this project",
cmCacheManager::INTERNAL);
// extract command line arguments that might add cache entries
this->SetCacheArgs(mf, args);
2001-09-07 01:28:24 +04:00
// no generator specified on the command line
if(!mf.GetMakefileGenerator())
{
cmMakefileGenerator* gen;
const char* genName = mf.GetDefinition("CMAKE_GENERATOR");
if(genName)
{
gen = cmMakefileGenerator::CreateGenerator(genName);
}
else
{
#if defined(__BORLANDC__)
gen = new cmBorlandMakefileGenerator;
#elif defined(_WIN32) && !defined(__CYGWIN__)
2001-09-07 01:28:24 +04:00
gen = new cmMSProjectGenerator;
2001-05-18 23:25:08 +04:00
#else
2001-09-07 01:28:24 +04:00
gen = new cmUnixMakefileGenerator;
2001-05-18 23:25:08 +04:00
#endif
2001-09-07 01:28:24 +04:00
}
if(!gen)
{
cmSystemTools::Error("Could not create generator");
return -1;
}
mf.SetMakefileGenerator(gen);
// add the
}
cmMakefileGenerator* gen = mf.GetMakefileGenerator();
2001-05-18 23:25:08 +04:00
gen->SetLocal(m_Local);
2002-04-25 21:09:17 +04:00
const char* genName = mf.GetDefinition("CMAKE_GENERATOR");
if(genName)
{
if(strcmp(gen->GetName(), genName) != 0)
{
std::string message = "Error: generator : ";
message += gen->GetName();
message += "\nDoes not match the generator used previously: ";
message += genName;
message +=
"\nEither remove the CMakeCache.txt file or choose a different"
" binary directory.";
cmSystemTools::Error(message.c_str());
return -2;
}
}
2001-09-07 01:28:24 +04:00
if(!mf.GetDefinition("CMAKE_GENERATOR"))
{
mf.AddCacheDefinition("CMAKE_GENERATOR",
gen->GetName(),
"Name of generator.",
cmCacheManager::INTERNAL);
}
2001-05-18 23:25:08 +04:00
// setup CMAKE_ROOT and CMAKE_COMMAND
2001-05-30 23:28:55 +04:00
this->AddCMakePaths(args);
2001-05-18 23:25:08 +04:00
// reset any system configuration information
cmMakefileGenerator::ClearEnabledLanguages();
2001-05-18 23:25:08 +04:00
std::string lf = mf.GetStartDirectory();
lf += "/CMakeLists.txt";
if(!mf.ReadListFile(lf.c_str()))
{
this->Usage(args[0].c_str());
return -1;
2001-05-18 23:25:08 +04:00
}
// if buildMakefiles, then call GenerateMakefile
if(buildMakefiles)
{
mf.GenerateMakefile();
}
else // do not build, but let the commands finalize
{
std::vector<cmMakefile*> makefiles;
mf.FindSubDirectoryCMakeListsFiles(makefiles);
for(std::vector<cmMakefile*>::iterator i = makefiles.begin();
i != makefiles.end(); ++i)
{
cmMakefile* mf = *i;
mf->FinalPass();
delete mf;
}
mf.FinalPass();
}
// Before saving the cache
// if the project did not define one of the entries below, add them now
// so users can edit the values in the cache:
// LIBRARY_OUTPUT_PATH
// EXECUTABLE_OUTPUT_PATH
if(!cmCacheManager::GetInstance()->GetCacheValue("LIBRARY_OUTPUT_PATH"))
{
cmCacheManager::GetInstance()->AddCacheEntry("LIBRARY_OUTPUT_PATH", "",
"Single output directory for building all libraries.",
cmCacheManager::PATH);
}
if(!cmCacheManager::GetInstance()->GetCacheValue("EXECUTABLE_OUTPUT_PATH"))
{
cmCacheManager::GetInstance()->AddCacheEntry("EXECUTABLE_OUTPUT_PATH", "",
"Single output directory for building all executables.",
cmCacheManager::PATH);
}
2001-05-18 23:25:08 +04:00
cmCacheManager::GetInstance()->SaveCache(&mf);
2001-05-18 23:25:08 +04:00
if(m_Verbose)
{
cmCacheManager::GetInstance()->PrintCache(std::cout);
}
if(cmSystemTools::GetErrorOccuredFlag())
{
return -1;
}
return 0;
}
2002-06-03 21:08:52 +04:00
void CMakeCommandUsage(const char* program)
{
std::strstream errorStream;
errorStream
<< "cmake version " << cmMakefile::GetMajorVersion()
<< "." << cmMakefile::GetMinorVersion() << "\n";
errorStream
<< "Usage: " << program << " -E [command] [arguments ...]\n"
<< "Available commands: \n"
<< " copy file destination - copy file to destination (either file or directory)\n"
<< " remove file1 file2 ... - remove the file(s)\n"
<< " time command [args] ... - run command and return elapsed time\n"
#if defined(_WIN32) && !defined(__CYGWIN__)
<< " write_regv key value - write registry value\n"
<< " delete_regv key - delete registry value\n"
#endif
<< std::ends;
cmSystemTools::Error(errorStream.str());
}
int cmake::CMakeCommand(std::vector<std::string>& args)
{
if (args.size() > 1)
{
// Copy file
if (args[1] == "copy" && args.size() == 4)
{
cmSystemTools::cmCopyFile(args[2].c_str(), args[3].c_str());
return cmSystemTools::GetErrorOccuredFlag();
}
// Remove file
else if (args[1] == "remove" && args.size() > 2)
{
for (std::string::size_type cc = 2; cc < args.size(); cc ++)
{
if(args[cc] != "-f")
{
if(args[cc] == "\\-f")
{
args[cc] = "-f";
}
cmSystemTools::RemoveFile(args[cc].c_str());
}
}
return 0;
}
// Clock command
else if (args[1] == "time" && args.size() > 2)
{
std::string command = args[2];
std::string output;
for (std::string::size_type cc = 3; cc < args.size(); cc ++)
{
command += " ";
command += args[cc];
}
clock_t clock_start, clock_finish;
time_t time_start, time_finish;
time(&time_start);
clock_start = clock();
cmSystemTools::RunCommand(command.c_str(), output, 0, true);
clock_finish = clock();
time(&time_finish);
std::cout << output.c_str();
double clocks_per_sec = (double)CLOCKS_PER_SEC;
std::cout << "Elapsed time: "
<< (long)(time_finish - time_start) << " s. (time)"
<< ", "
<< (double)(clock_finish - clock_start) / clocks_per_sec
<< " s. (clock)"
<< "\n";
return 0;
}
#if defined(_WIN32) && !defined(__CYGWIN__)
// Write registry value
else if (args[1] == "write_regv" && args.size() > 3)
{
return cmSystemTools::WriteRegistryValue(args[2].c_str(),
args[3].c_str()) ? 0 : 1;
}
// Delete registry value
else if (args[1] == "delete_regv" && args.size() > 2)
{
return cmSystemTools::DeleteRegistryValue(args[2].c_str()) ? 0 : 1;
}
#endif
}
::CMakeCommandUsage(args[0].c_str());
return 1;
}