STYLE: Fix some style issues
This commit is contained in:
parent
f01afc89f5
commit
634343c3e8
|
@ -39,7 +39,7 @@ cmCPackGenerators::cmCPackGenerators()
|
|||
cmCPackGenerators::~cmCPackGenerators()
|
||||
{
|
||||
std::vector<cmCPackGenericGenerator*>::iterator it;
|
||||
for ( it = m_Generators.begin(); it != m_Generators.end(); ++ it )
|
||||
for ( it = this->Generators.begin(); it != this->Generators.end(); ++ it )
|
||||
{
|
||||
delete *it;
|
||||
}
|
||||
|
@ -53,8 +53,8 @@ cmCPackGenericGenerator* cmCPackGenerators::NewGenerator(const char* name)
|
|||
{
|
||||
return 0;
|
||||
}
|
||||
m_Generators.push_back(gen);
|
||||
gen->SetLogger(m_Logger);
|
||||
this->Generators.push_back(gen);
|
||||
gen->SetLogger(this->Logger);
|
||||
return gen;
|
||||
}
|
||||
|
||||
|
@ -67,8 +67,8 @@ cmCPackGenericGenerator* cmCPackGenerators::NewGeneratorInternal(
|
|||
return 0;
|
||||
}
|
||||
cmCPackGenerators::t_GeneratorCreatorsMap::iterator it
|
||||
= m_GeneratorCreators.find(name);
|
||||
if ( it == m_GeneratorCreators.end() )
|
||||
= this->GeneratorCreators.find(name);
|
||||
if ( it == this->GeneratorCreators.end() )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
@ -81,9 +81,9 @@ void cmCPackGenerators::RegisterGenerator(const char* name,
|
|||
{
|
||||
if ( !name || !createGenerator )
|
||||
{
|
||||
cmCPack_Log(m_Logger, cmCPackLog::LOG_ERROR, "Cannot register generator"
|
||||
<< std::endl);
|
||||
cmCPack_Log(this->Logger, cmCPackLog::LOG_ERROR,
|
||||
"Cannot register generator" << std::endl);
|
||||
return;
|
||||
}
|
||||
m_GeneratorCreators[name] = createGenerator;
|
||||
this->GeneratorCreators[name] = createGenerator;
|
||||
}
|
||||
|
|
|
@ -44,15 +44,15 @@ public:
|
|||
void RegisterGenerator(const char* name,
|
||||
CreateGeneratorCall* createGenerator);
|
||||
|
||||
void SetLogger(cmCPackLog* logger) { m_Logger = logger; }
|
||||
void SetLogger(cmCPackLog* logger) { this->Logger = logger; }
|
||||
|
||||
private:
|
||||
cmCPackGenericGenerator* NewGeneratorInternal(const char* name);
|
||||
std::vector<cmCPackGenericGenerator*> m_Generators;
|
||||
std::vector<cmCPackGenericGenerator*> Generators;
|
||||
|
||||
typedef std::map<cmStdString, CreateGeneratorCall*> t_GeneratorCreatorsMap;
|
||||
t_GeneratorCreatorsMap m_GeneratorCreators;
|
||||
cmCPackLog* m_Logger;
|
||||
t_GeneratorCreatorsMap GeneratorCreators;
|
||||
cmCPackLog* Logger;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
@ -31,21 +31,21 @@
|
|||
//----------------------------------------------------------------------
|
||||
cmCPackGenericGenerator::cmCPackGenericGenerator()
|
||||
{
|
||||
m_GeneratorVerbose = false;
|
||||
m_MakefileMap = 0;
|
||||
m_Logger = 0;
|
||||
this->GeneratorVerbose = false;
|
||||
this->MakefileMap = 0;
|
||||
this->Logger = 0;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
cmCPackGenericGenerator::~cmCPackGenericGenerator()
|
||||
{
|
||||
m_MakefileMap = 0;
|
||||
this->MakefileMap = 0;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
int cmCPackGenericGenerator::PrepareNames()
|
||||
{
|
||||
this->SetOption("CPACK_GENERATOR", m_Name.c_str());
|
||||
this->SetOption("CPACK_GENERATOR", this->Name.c_str());
|
||||
std::string tempDirectory = this->GetOption("CPACK_PACKAGE_DIRECTORY");
|
||||
tempDirectory += "/_CPack_Packages/";
|
||||
tempDirectory += this->GetOption("CPACK_GENERATOR");
|
||||
|
@ -157,7 +157,7 @@ int cmCPackGenericGenerator::InstallProject()
|
|||
std::string output;
|
||||
int retVal = 1;
|
||||
bool resB = cmSystemTools::RunSingleCommand(it->c_str(), &output,
|
||||
&retVal, 0, m_GeneratorVerbose, 0);
|
||||
&retVal, 0, this->GeneratorVerbose, 0);
|
||||
if ( !resB || retVal )
|
||||
{
|
||||
std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
|
||||
|
@ -272,12 +272,12 @@ void cmCPackGenericGenerator::SetOption(const char* op, const char* value)
|
|||
}
|
||||
if ( !value )
|
||||
{
|
||||
m_MakefileMap->RemoveDefinition(op);
|
||||
this->MakefileMap->RemoveDefinition(op);
|
||||
return;
|
||||
}
|
||||
cmCPackLogger(cmCPackLog::LOG_DEBUG, this->GetNameOfClass()
|
||||
<< "::SetOption(" << op << ", " << value << ")" << std::endl);
|
||||
m_MakefileMap->AddDefinition(op, value);
|
||||
this->MakefileMap->AddDefinition(op, value);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
@ -346,15 +346,15 @@ int cmCPackGenericGenerator::ProcessGenerator()
|
|||
//----------------------------------------------------------------------
|
||||
int cmCPackGenericGenerator::Initialize(const char* name, cmMakefile* mf)
|
||||
{
|
||||
m_MakefileMap = mf;
|
||||
m_Name = name;
|
||||
this->MakefileMap = mf;
|
||||
this->Name = name;
|
||||
return 1;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
const char* cmCPackGenericGenerator::GetOption(const char* op)
|
||||
{
|
||||
return m_MakefileMap->GetDefinition(op);
|
||||
return this->MakefileMap->GetDefinition(op);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
@ -363,18 +363,18 @@ int cmCPackGenericGenerator::FindRunningCMake(const char* arg0)
|
|||
int found = 0;
|
||||
// Find our own executable.
|
||||
std::vector<cmStdString> failures;
|
||||
m_CPackSelf = arg0;
|
||||
cmSystemTools::ConvertToUnixSlashes(m_CPackSelf);
|
||||
failures.push_back(m_CPackSelf);
|
||||
m_CPackSelf = cmSystemTools::FindProgram(m_CPackSelf.c_str());
|
||||
if(!cmSystemTools::FileExists(m_CPackSelf.c_str()))
|
||||
this->CPackSelf = arg0;
|
||||
cmSystemTools::ConvertToUnixSlashes(this->CPackSelf);
|
||||
failures.push_back(this->CPackSelf);
|
||||
this->CPackSelf = cmSystemTools::FindProgram(this->CPackSelf.c_str());
|
||||
if(!cmSystemTools::FileExists(this->CPackSelf.c_str()))
|
||||
{
|
||||
failures.push_back(m_CPackSelf);
|
||||
m_CPackSelf = "/usr/local/bin/ctest";
|
||||
failures.push_back(this->CPackSelf);
|
||||
this->CPackSelf = "/usr/local/bin/ctest";
|
||||
}
|
||||
if(!cmSystemTools::FileExists(m_CPackSelf.c_str()))
|
||||
if(!cmSystemTools::FileExists(this->CPackSelf.c_str()))
|
||||
{
|
||||
failures.push_back(m_CPackSelf);
|
||||
failures.push_back(this->CPackSelf);
|
||||
cmOStringStream msg;
|
||||
msg << "CTEST can not find the command line program ctest.\n";
|
||||
msg << " argv[0] = \"" << arg0 << "\"\n";
|
||||
|
@ -388,33 +388,33 @@ int cmCPackGenericGenerator::FindRunningCMake(const char* arg0)
|
|||
}
|
||||
std::string dir;
|
||||
std::string file;
|
||||
if(cmSystemTools::SplitProgramPath(m_CPackSelf.c_str(),
|
||||
if(cmSystemTools::SplitProgramPath(this->CPackSelf.c_str(),
|
||||
dir, file, true))
|
||||
{
|
||||
m_CMakeSelf = dir += "/cmake";
|
||||
m_CMakeSelf += cmSystemTools::GetExecutableExtension();
|
||||
if(cmSystemTools::FileExists(m_CMakeSelf.c_str()))
|
||||
this->CMakeSelf = dir += "/cmake";
|
||||
this->CMakeSelf += cmSystemTools::GetExecutableExtension();
|
||||
if(cmSystemTools::FileExists(this->CMakeSelf.c_str()))
|
||||
{
|
||||
found = 1;
|
||||
}
|
||||
}
|
||||
if ( !found )
|
||||
{
|
||||
failures.push_back(m_CMakeSelf);
|
||||
failures.push_back(this->CMakeSelf);
|
||||
#ifdef CMAKE_BUILD_DIR
|
||||
std::string intdir = ".";
|
||||
#ifdef CMAKE_INTDIR
|
||||
intdir = CMAKE_INTDIR;
|
||||
#endif
|
||||
m_CMakeSelf = CMAKE_BUILD_DIR;
|
||||
m_CMakeSelf += "/bin/";
|
||||
m_CMakeSelf += intdir;
|
||||
m_CMakeSelf += "/cmake";
|
||||
m_CMakeSelf += cmSystemTools::GetExecutableExtension();
|
||||
this->CMakeSelf = CMAKE_BUILD_DIR;
|
||||
this->CMakeSelf += "/bin/";
|
||||
this->CMakeSelf += intdir;
|
||||
this->CMakeSelf += "/cmake";
|
||||
this->CMakeSelf += cmSystemTools::GetExecutableExtension();
|
||||
#endif
|
||||
if(!cmSystemTools::FileExists(m_CMakeSelf.c_str()))
|
||||
if(!cmSystemTools::FileExists(this->CMakeSelf.c_str()))
|
||||
{
|
||||
failures.push_back(m_CMakeSelf);
|
||||
failures.push_back(this->CMakeSelf);
|
||||
cmOStringStream msg;
|
||||
msg << "CTEST can not find the command line program cmake.\n";
|
||||
msg << " argv[0] = \"" << arg0 << "\"\n";
|
||||
|
@ -439,7 +439,7 @@ int cmCPackGenericGenerator::FindRunningCMake(const char* arg0)
|
|||
if(modules.empty() || !cmSystemTools::FileExists(modules.c_str()))
|
||||
{
|
||||
// next try exe/..
|
||||
cMakeRoot = cmSystemTools::GetProgramPath(m_CMakeSelf.c_str());
|
||||
cMakeRoot = cmSystemTools::GetProgramPath(this->CMakeSelf.c_str());
|
||||
std::string::size_type slashPos = cMakeRoot.rfind("/");
|
||||
if(slashPos != std::string::npos)
|
||||
{
|
||||
|
@ -482,7 +482,7 @@ int cmCPackGenericGenerator::FindRunningCMake(const char* arg0)
|
|||
if (!cmSystemTools::FileExists(modules.c_str()))
|
||||
{
|
||||
// try
|
||||
cMakeRoot = cmSystemTools::GetProgramPath(m_CMakeSelf.c_str());
|
||||
cMakeRoot = cmSystemTools::GetProgramPath(this->CMakeSelf.c_str());
|
||||
cMakeRoot += CMAKE_DATA_DIR;
|
||||
modules = cMakeRoot + "/Modules/CMake.cmake";
|
||||
cmCPackLogger(cmCPackLog::LOG_DEBUG, "Looking for CMAKE_ROOT: "
|
||||
|
@ -491,7 +491,7 @@ int cmCPackGenericGenerator::FindRunningCMake(const char* arg0)
|
|||
if(!cmSystemTools::FileExists(modules.c_str()))
|
||||
{
|
||||
// next try exe
|
||||
cMakeRoot = cmSystemTools::GetProgramPath(m_CMakeSelf.c_str());
|
||||
cMakeRoot = cmSystemTools::GetProgramPath(this->CMakeSelf.c_str());
|
||||
// is there no Modules direcory there?
|
||||
modules = cMakeRoot + "/Modules/CMake.cmake";
|
||||
cmCPackLogger(cmCPackLog::LOG_DEBUG, "Looking for CMAKE_ROOT: "
|
||||
|
@ -506,10 +506,10 @@ int cmCPackGenericGenerator::FindRunningCMake(const char* arg0)
|
|||
cMakeRoot.c_str());
|
||||
return 0;
|
||||
}
|
||||
m_CMakeRoot = cMakeRoot;
|
||||
this->CMakeRoot = cMakeRoot;
|
||||
cmCPackLogger(cmCPackLog::LOG_DEBUG, "Looking for CMAKE_ROOT: "
|
||||
<< m_CMakeRoot.c_str() << std::endl);
|
||||
this->SetOption("CMAKE_ROOT", m_CMakeRoot.c_str());
|
||||
<< this->CMakeRoot.c_str() << std::endl);
|
||||
this->SetOption("CMAKE_ROOT", this->CMakeRoot.c_str());
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
@ -526,34 +526,34 @@ int cmCPackGenericGenerator::CompressFiles(const char* outFileName,
|
|||
//----------------------------------------------------------------------
|
||||
const char* cmCPackGenericGenerator::GetInstallPath()
|
||||
{
|
||||
if ( !m_InstallPath.empty() )
|
||||
if ( !this->InstallPath.empty() )
|
||||
{
|
||||
return m_InstallPath.c_str();
|
||||
return this->InstallPath.c_str();
|
||||
}
|
||||
#if defined(_WIN32) && !defined(__CYGWIN__)
|
||||
const char* prgfiles = cmsys::SystemTools::GetEnv("ProgramFiles");
|
||||
const char* sysDrive = cmsys::SystemTools::GetEnv("SystemDrive");
|
||||
if ( prgfiles )
|
||||
{
|
||||
m_InstallPath = prgfiles;
|
||||
this->InstallPath = prgfiles;
|
||||
}
|
||||
else if ( sysDrive )
|
||||
{
|
||||
m_InstallPath = sysDrive;
|
||||
m_InstallPath += "/Program Files";
|
||||
this->InstallPath = sysDrive;
|
||||
this->InstallPath += "/Program Files";
|
||||
}
|
||||
else
|
||||
{
|
||||
m_InstallPath = "c:/Program Files";
|
||||
this->InstallPath = "c:/Program Files";
|
||||
}
|
||||
m_InstallPath += "/";
|
||||
m_InstallPath += this->GetOption("CPACK_PACKAGE_NAME");
|
||||
m_InstallPath += "-";
|
||||
m_InstallPath += this->GetOption("CPACK_PACKAGE_VERSION");
|
||||
this->InstallPath += "/";
|
||||
this->InstallPath += this->GetOption("CPACK_PACKAGE_NAME");
|
||||
this->InstallPath += "-";
|
||||
this->InstallPath += this->GetOption("CPACK_PACKAGE_VERSION");
|
||||
#else
|
||||
m_InstallPath = "/usr/local/";
|
||||
this->InstallPath = "/usr/local/";
|
||||
#endif
|
||||
return m_InstallPath.c_str();
|
||||
return this->InstallPath.c_str();
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
@ -561,7 +561,7 @@ std::string cmCPackGenericGenerator::FindTemplate(const char* name)
|
|||
{
|
||||
cmCPackLogger(cmCPackLog::LOG_DEBUG, "Look for template: "
|
||||
<< name << std::endl);
|
||||
std::string ffile = m_MakefileMap->GetModulesFile(name);
|
||||
std::string ffile = this->MakefileMap->GetModulesFile(name);
|
||||
cmCPackLogger(cmCPackLog::LOG_DEBUG, "Found template: "
|
||||
<< ffile.c_str() << std::endl);
|
||||
return ffile;
|
||||
|
@ -571,6 +571,6 @@ std::string cmCPackGenericGenerator::FindTemplate(const char* name)
|
|||
bool cmCPackGenericGenerator::ConfigureFile(const char* inName,
|
||||
const char* outName)
|
||||
{
|
||||
return m_MakefileMap->ConfigureFile(inName, outName,
|
||||
return this->MakefileMap->ConfigureFile(inName, outName,
|
||||
false, true, false) == 1;
|
||||
}
|
||||
|
|
|
@ -29,7 +29,7 @@
|
|||
do { \
|
||||
cmOStringStream cmCPackLog_msg; \
|
||||
cmCPackLog_msg << msg; \
|
||||
m_Logger->Log(logType, __FILE__, __LINE__, cmCPackLog_msg.str().c_str());\
|
||||
this->Logger->Log(logType, __FILE__, __LINE__, cmCPackLog_msg.str().c_str());\
|
||||
} while ( 0 )
|
||||
|
||||
#ifdef cerr
|
||||
|
@ -56,7 +56,7 @@ public:
|
|||
/**
|
||||
* If verbose then more informaiton is printed out
|
||||
*/
|
||||
void SetVerbose(bool val) { m_GeneratorVerbose = val; }
|
||||
void SetVerbose(bool val) { this->GeneratorVerbose = val; }
|
||||
|
||||
/**
|
||||
* Do the actual processing. Subclass has to override it.
|
||||
|
@ -83,7 +83,7 @@ public:
|
|||
int FindRunningCMake(const char* arg0);
|
||||
|
||||
//! Set the logger
|
||||
void SetLogger(cmCPackLog* log) { m_Logger = log; }
|
||||
void SetLogger(cmCPackLog* log) { this->Logger = log; }
|
||||
|
||||
protected:
|
||||
int PrepareNames();
|
||||
|
@ -99,19 +99,19 @@ protected:
|
|||
virtual std::string FindTemplate(const char* name);
|
||||
virtual bool ConfigureFile(const char* inName, const char* outName);
|
||||
|
||||
bool m_GeneratorVerbose;
|
||||
std::string m_Name;
|
||||
bool GeneratorVerbose;
|
||||
std::string Name;
|
||||
|
||||
std::string m_InstallPath;
|
||||
std::string InstallPath;
|
||||
|
||||
std::string m_CPackSelf;
|
||||
std::string m_CMakeSelf;
|
||||
std::string m_CMakeRoot;
|
||||
std::string CPackSelf;
|
||||
std::string CMakeSelf;
|
||||
std::string CMakeRoot;
|
||||
|
||||
cmCPackLog* m_Logger;
|
||||
cmCPackLog* Logger;
|
||||
|
||||
private:
|
||||
cmMakefile* m_MakefileMap;
|
||||
cmMakefile* MakefileMap;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
@ -22,19 +22,19 @@
|
|||
//----------------------------------------------------------------------
|
||||
cmCPackLog::cmCPackLog()
|
||||
{
|
||||
m_Verbose = false;
|
||||
m_Debug = false;
|
||||
m_Quiet = false;
|
||||
m_NewLine = true;
|
||||
this->Verbose = false;
|
||||
this->Debug = false;
|
||||
this->Quiet = false;
|
||||
this->NewLine = true;
|
||||
|
||||
m_LastTag = cmCPackLog::NOTAG;
|
||||
this->LastTag = cmCPackLog::NOTAG;
|
||||
#undef cerr
|
||||
#undef cout
|
||||
m_DefaultOutput = &std::cout;
|
||||
m_DefaultError = &std::cerr;
|
||||
this->DefaultOutput = &std::cout;
|
||||
this->DefaultError = &std::cerr;
|
||||
|
||||
m_LogOutput = 0;
|
||||
m_LogOutputCleanup = false;
|
||||
this->LogOutput = 0;
|
||||
this->LogOutputCleanup = false;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
@ -46,12 +46,12 @@ cmCPackLog::~cmCPackLog()
|
|||
//----------------------------------------------------------------------
|
||||
void cmCPackLog::SetLogOutputStream(std::ostream* os)
|
||||
{
|
||||
if ( m_LogOutputCleanup && m_LogOutput )
|
||||
if ( this->LogOutputCleanup && this->LogOutput )
|
||||
{
|
||||
delete m_LogOutput;
|
||||
delete this->LogOutput;
|
||||
}
|
||||
m_LogOutputCleanup = false;
|
||||
m_LogOutput = os;
|
||||
this->LogOutputCleanup = false;
|
||||
this->LogOutput = os;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
@ -72,7 +72,7 @@ bool cmCPackLog::SetLogOutputFile(const char* fname)
|
|||
{
|
||||
return false;
|
||||
}
|
||||
m_LogOutputCleanup = true;
|
||||
this->LogOutputCleanup = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
@ -84,7 +84,7 @@ void cmCPackLog::Log(int tag, const char* file, int line,
|
|||
bool display = false;
|
||||
|
||||
// Display file and line number if debug
|
||||
bool useFileAndLine = m_Debug;
|
||||
bool useFileAndLine = this->Debug;
|
||||
|
||||
bool output = false;
|
||||
bool debug = false;
|
||||
|
@ -95,7 +95,7 @@ void cmCPackLog::Log(int tag, const char* file, int line,
|
|||
// When writing in file, add list of tags whenever tag changes.
|
||||
std::string tagString;
|
||||
bool needTagString = false;
|
||||
if ( m_LogOutput && m_LastTag != tag )
|
||||
if ( this->LogOutput && this->LastTag != tag )
|
||||
{
|
||||
needTagString = true;
|
||||
}
|
||||
|
@ -130,7 +130,7 @@ void cmCPackLog::Log(int tag, const char* file, int line,
|
|||
tagString = "ERROR";
|
||||
}
|
||||
}
|
||||
if ( tag & LOG_DEBUG && m_Debug )
|
||||
if ( tag & LOG_DEBUG && this->Debug )
|
||||
{
|
||||
debug = true;
|
||||
display = true;
|
||||
|
@ -141,7 +141,7 @@ void cmCPackLog::Log(int tag, const char* file, int line,
|
|||
}
|
||||
useFileAndLine = true;
|
||||
}
|
||||
if ( tag & LOG_VERBOSE && m_Verbose )
|
||||
if ( tag & LOG_VERBOSE && this->Verbose )
|
||||
{
|
||||
verbose = true;
|
||||
display = true;
|
||||
|
@ -151,73 +151,74 @@ void cmCPackLog::Log(int tag, const char* file, int line,
|
|||
tagString = "VERBOSE";
|
||||
}
|
||||
}
|
||||
if ( m_Quiet )
|
||||
if ( this->Quiet )
|
||||
{
|
||||
display = false;
|
||||
}
|
||||
if ( m_LogOutput )
|
||||
if ( this->LogOutput )
|
||||
{
|
||||
if ( needTagString )
|
||||
{
|
||||
*m_LogOutput << "[" << file << ":" << line << " " << tagString << "] ";
|
||||
*this->LogOutput << "[" << file << ":" << line << " "
|
||||
<< tagString << "] ";
|
||||
}
|
||||
m_LogOutput->write(msg, length);
|
||||
this->LogOutput->write(msg, length);
|
||||
}
|
||||
m_LastTag = tag;
|
||||
this->LastTag = tag;
|
||||
if ( !display )
|
||||
{
|
||||
return;
|
||||
}
|
||||
if ( m_NewLine )
|
||||
if ( this->NewLine )
|
||||
{
|
||||
if ( error && !m_ErrorPrefix.empty() )
|
||||
if ( error && !this->ErrorPrefix.empty() )
|
||||
{
|
||||
*m_DefaultError << m_ErrorPrefix.c_str();
|
||||
*this->DefaultError << this->ErrorPrefix.c_str();
|
||||
}
|
||||
else if ( warning && !m_WarningPrefix.empty() )
|
||||
else if ( warning && !this->WarningPrefix.empty() )
|
||||
{
|
||||
*m_DefaultError << m_WarningPrefix.c_str();
|
||||
*this->DefaultError << this->WarningPrefix.c_str();
|
||||
}
|
||||
else if ( output && !m_OutputPrefix.empty() )
|
||||
else if ( output && !this->OutputPrefix.empty() )
|
||||
{
|
||||
*m_DefaultOutput << m_OutputPrefix.c_str();
|
||||
*this->DefaultOutput << this->OutputPrefix.c_str();
|
||||
}
|
||||
else if ( verbose && !m_VerbosePrefix.empty() )
|
||||
else if ( verbose && !this->VerbosePrefix.empty() )
|
||||
{
|
||||
*m_DefaultOutput << m_VerbosePrefix.c_str();
|
||||
*this->DefaultOutput << this->VerbosePrefix.c_str();
|
||||
}
|
||||
else if ( debug && !m_DebugPrefix.empty() )
|
||||
else if ( debug && !this->DebugPrefix.empty() )
|
||||
{
|
||||
*m_DefaultOutput << m_DebugPrefix.c_str();
|
||||
*this->DefaultOutput << this->DebugPrefix.c_str();
|
||||
}
|
||||
else if ( !m_Prefix.empty() )
|
||||
else if ( !this->Prefix.empty() )
|
||||
{
|
||||
*m_DefaultOutput << m_Prefix.c_str();
|
||||
*this->DefaultOutput << this->Prefix.c_str();
|
||||
}
|
||||
if ( useFileAndLine )
|
||||
{
|
||||
if ( error || warning )
|
||||
{
|
||||
*m_DefaultError << file << ":" << line << " ";
|
||||
*this->DefaultError << file << ":" << line << " ";
|
||||
}
|
||||
else
|
||||
{
|
||||
*m_DefaultOutput << file << ":" << line << " ";
|
||||
*this->DefaultOutput << file << ":" << line << " ";
|
||||
}
|
||||
}
|
||||
}
|
||||
if ( error || warning )
|
||||
{
|
||||
m_DefaultError->write(msg, length);
|
||||
m_DefaultError->flush();
|
||||
this->DefaultError->write(msg, length);
|
||||
this->DefaultError->flush();
|
||||
}
|
||||
else
|
||||
{
|
||||
m_DefaultOutput->write(msg, length);
|
||||
m_DefaultOutput->flush();
|
||||
this->DefaultOutput->write(msg, length);
|
||||
this->DefaultOutput->flush();
|
||||
}
|
||||
if ( msg[length-1] == '\n' || length > 2 )
|
||||
{
|
||||
m_NewLine = true;
|
||||
this->NewLine = true;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -78,26 +78,26 @@ public:
|
|||
//! Set Verbose
|
||||
void VerboseOn() { this->SetVerbose(true); }
|
||||
void VerboseOff() { this->SetVerbose(true); }
|
||||
void SetVerbose(bool verb) { m_Verbose = verb; }
|
||||
bool GetVerbose() { return m_Verbose; }
|
||||
void SetVerbose(bool verb) { this->Verbose = verb; }
|
||||
bool GetVerbose() { return this->Verbose; }
|
||||
|
||||
//! Set Debug
|
||||
void DebugOn() { this->SetDebug(true); }
|
||||
void DebugOff() { this->SetDebug(true); }
|
||||
void SetDebug(bool verb) { m_Debug = verb; }
|
||||
bool GetDebug() { return m_Debug; }
|
||||
void SetDebug(bool verb) { this->Debug = verb; }
|
||||
bool GetDebug() { return this->Debug; }
|
||||
|
||||
//! Set Quiet
|
||||
void QuietOn() { this->SetQuiet(true); }
|
||||
void QuietOff() { this->SetQuiet(true); }
|
||||
void SetQuiet(bool verb) { m_Quiet = verb; }
|
||||
bool GetQuiet() { return m_Quiet; }
|
||||
void SetQuiet(bool verb) { this->Quiet = verb; }
|
||||
bool GetQuiet() { return this->Quiet; }
|
||||
|
||||
//! Set the output stream
|
||||
void SetOutputStream(std::ostream* os) { m_DefaultOutput = os; }
|
||||
void SetOutputStream(std::ostream* os) { this->DefaultOutput = os; }
|
||||
|
||||
//! Set the error stream
|
||||
void SetErrorStream(std::ostream* os) { m_DefaultError = os; }
|
||||
void SetErrorStream(std::ostream* os) { this->DefaultError = os; }
|
||||
|
||||
//! Set the log output stream
|
||||
void SetLogOutputStream(std::ostream* os);
|
||||
|
@ -108,36 +108,36 @@ public:
|
|||
|
||||
//! Set the various prefixes for the logging. SetPrefix sets the generic
|
||||
// prefix that overwrittes missing ones.
|
||||
void SetPrefix(std::string pfx) { m_Prefix = pfx; }
|
||||
void SetOutputPrefix(std::string pfx) { m_OutputPrefix = pfx; }
|
||||
void SetVerbosePrefix(std::string pfx) { m_VerbosePrefix = pfx; }
|
||||
void SetDebugPrefix(std::string pfx) { m_DebugPrefix = pfx; }
|
||||
void SetWarningPrefix(std::string pfx) { m_WarningPrefix = pfx; }
|
||||
void SetErrorPrefix(std::string pfx) { m_ErrorPrefix = pfx; }
|
||||
void SetPrefix(std::string pfx) { this->Prefix = pfx; }
|
||||
void SetOutputPrefix(std::string pfx) { this->OutputPrefix = pfx; }
|
||||
void SetVerbosePrefix(std::string pfx) { this->VerbosePrefix = pfx; }
|
||||
void SetDebugPrefix(std::string pfx) { this->DebugPrefix = pfx; }
|
||||
void SetWarningPrefix(std::string pfx) { this->WarningPrefix = pfx; }
|
||||
void SetErrorPrefix(std::string pfx) { this->ErrorPrefix = pfx; }
|
||||
|
||||
private:
|
||||
bool m_Verbose;
|
||||
bool m_Debug;
|
||||
bool m_Quiet;
|
||||
bool Verbose;
|
||||
bool Debug;
|
||||
bool Quiet;
|
||||
|
||||
bool m_NewLine;
|
||||
bool NewLine;
|
||||
|
||||
int m_LastTag;
|
||||
int LastTag;
|
||||
|
||||
std::string m_Prefix;
|
||||
std::string m_OutputPrefix;
|
||||
std::string m_VerbosePrefix;
|
||||
std::string m_DebugPrefix;
|
||||
std::string m_WarningPrefix;
|
||||
std::string m_ErrorPrefix;
|
||||
std::string Prefix;
|
||||
std::string OutputPrefix;
|
||||
std::string VerbosePrefix;
|
||||
std::string DebugPrefix;
|
||||
std::string WarningPrefix;
|
||||
std::string ErrorPrefix;
|
||||
|
||||
std::ostream *m_DefaultOutput;
|
||||
std::ostream *m_DefaultError;
|
||||
std::ostream *DefaultOutput;
|
||||
std::ostream *DefaultError;
|
||||
|
||||
std::string m_LogOutputFileName;
|
||||
std::ostream *m_LogOutput;
|
||||
std::string LogOutputFileName;
|
||||
std::ostream *LogOutput;
|
||||
// Do we need to cleanup log output stream
|
||||
bool m_LogOutputCleanup;
|
||||
bool LogOutputCleanup;
|
||||
};
|
||||
|
||||
class cmCPackLogWrite
|
||||
|
|
|
@ -99,7 +99,7 @@ int cmCPackNSISGenerator::CompressFiles(const char* outFileName,
|
|||
std::string output;
|
||||
int retVal = 1;
|
||||
bool res = cmSystemTools::RunSingleCommand(nsisCmd.c_str(), &output,
|
||||
&retVal, 0, m_GeneratorVerbose, 0);
|
||||
&retVal, 0, this->GeneratorVerbose, 0);
|
||||
if ( !res || retVal )
|
||||
{
|
||||
cmGeneratedFileStream ofs(tmpFile.c_str());
|
||||
|
@ -147,7 +147,7 @@ int cmCPackNSISGenerator::Initialize(const char* name, cmMakefile* mf)
|
|||
std::string output;
|
||||
int retVal = 1;
|
||||
bool resS = cmSystemTools::RunSingleCommand(nsisCmd.c_str(),
|
||||
&output, &retVal, 0, m_GeneratorVerbose, 0);
|
||||
&output, &retVal, 0, this->GeneratorVerbose, 0);
|
||||
|
||||
cmsys::RegularExpression versionRex("v([0-9]+.[0-9]+)");
|
||||
if ( !resS || retVal || !versionRex.find(output))
|
||||
|
|
|
@ -95,7 +95,7 @@ int cmCPackPackageMakerGenerator::CompressFiles(const char* outFileName,
|
|||
std::string output;
|
||||
int retVal = 1;
|
||||
//bool res = cmSystemTools::RunSingleCommand(pkgCmd.str().c_str(), &output,
|
||||
//&retVal, 0, m_GeneratorVerbose, 0);
|
||||
//&retVal, 0, this->GeneratorVerbose, 0);
|
||||
bool res = true;
|
||||
retVal = system(pkgCmd.str().c_str());
|
||||
cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Done running package maker"
|
||||
|
@ -120,7 +120,7 @@ int cmCPackPackageMakerGenerator::CompressFiles(const char* outFileName,
|
|||
<< "\" create -ov -format UDZO -srcfolder \"" << packageDirFileName
|
||||
<< "\" \"" << outFileName << "\"";
|
||||
res = cmSystemTools::RunSingleCommand(dmgCmd.str().c_str(), &output,
|
||||
&retVal, 0, m_GeneratorVerbose, 0);
|
||||
&retVal, 0, this->GeneratorVerbose, 0);
|
||||
if ( !res || retVal )
|
||||
{
|
||||
cmGeneratedFileStream ofs(tmpFile.c_str());
|
||||
|
|
|
@ -60,13 +60,13 @@ class cmCPackTGZ_Data
|
|||
public:
|
||||
cmCPackTGZ_Data(cmCPackTGZGenerator* gen) :
|
||||
OutputStream(0), Generator(gen),
|
||||
m_CompressionLevel(Z_DEFAULT_COMPRESSION) {}
|
||||
CompressionLevel(Z_DEFAULT_COMPRESSION) {}
|
||||
std::ostream* OutputStream;
|
||||
cmCPackTGZGenerator* Generator;
|
||||
char m_CompressedBuffer[cmCPackTGZ_Data_BlockSize];
|
||||
int m_CompressionLevel;
|
||||
z_stream m_ZLibStream;
|
||||
uLong m_CRC;
|
||||
char CompressedBuffer[cmCPackTGZ_Data_BlockSize];
|
||||
int CompressionLevel;
|
||||
z_stream ZLibStream;
|
||||
uLong CRC;
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
@ -84,11 +84,11 @@ int cmCPackTGZ_Data_Open(void *client_data, const char* pathname,
|
|||
{
|
||||
cmCPackTGZ_Data *mydata = (cmCPackTGZ_Data*)client_data;
|
||||
|
||||
mydata->m_ZLibStream.zalloc = Z_NULL;
|
||||
mydata->m_ZLibStream.zfree = Z_NULL;
|
||||
mydata->m_ZLibStream.opaque = Z_NULL;
|
||||
mydata->ZLibStream.zalloc = Z_NULL;
|
||||
mydata->ZLibStream.zfree = Z_NULL;
|
||||
mydata->ZLibStream.opaque = Z_NULL;
|
||||
int strategy = Z_DEFAULT_STRATEGY;
|
||||
if ( deflateInit2(&mydata->m_ZLibStream, mydata->m_CompressionLevel,
|
||||
if ( deflateInit2(&mydata->ZLibStream, mydata->CompressionLevel,
|
||||
Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, strategy) != Z_OK )
|
||||
{
|
||||
return -1;
|
||||
|
@ -108,7 +108,7 @@ int cmCPackTGZ_Data_Open(void *client_data, const char* pathname,
|
|||
return -1;
|
||||
}
|
||||
|
||||
mydata->m_CRC = crc32(0L, Z_NULL, 0);
|
||||
mydata->CRC = crc32(0L, Z_NULL, 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -118,27 +118,27 @@ ssize_t cmCPackTGZ_Data_Write(void *client_data, void *buff, size_t n)
|
|||
{
|
||||
cmCPackTGZ_Data *mydata = (cmCPackTGZ_Data*)client_data;
|
||||
|
||||
mydata->m_ZLibStream.avail_in = n;
|
||||
mydata->m_ZLibStream.next_in = reinterpret_cast<Bytef*>(buff);
|
||||
mydata->ZLibStream.avail_in = n;
|
||||
mydata->ZLibStream.next_in = reinterpret_cast<Bytef*>(buff);
|
||||
|
||||
do {
|
||||
mydata->m_ZLibStream.avail_out = cmCPackTGZ_Data_BlockSize;
|
||||
mydata->m_ZLibStream.next_out
|
||||
= reinterpret_cast<Bytef*>(mydata->m_CompressedBuffer);
|
||||
mydata->ZLibStream.avail_out = cmCPackTGZ_Data_BlockSize;
|
||||
mydata->ZLibStream.next_out
|
||||
= reinterpret_cast<Bytef*>(mydata->CompressedBuffer);
|
||||
// no bad return value
|
||||
int ret = deflate(&mydata->m_ZLibStream, (n?Z_NO_FLUSH:Z_FINISH));
|
||||
int ret = deflate(&mydata->ZLibStream, (n?Z_NO_FLUSH:Z_FINISH));
|
||||
if(ret == Z_STREAM_ERROR)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
size_t compressedSize
|
||||
= cmCPackTGZ_Data_BlockSize - mydata->m_ZLibStream.avail_out;
|
||||
= cmCPackTGZ_Data_BlockSize - mydata->ZLibStream.avail_out;
|
||||
|
||||
mydata->OutputStream->write(
|
||||
reinterpret_cast<const char*>(mydata->m_CompressedBuffer),
|
||||
reinterpret_cast<const char*>(mydata->CompressedBuffer),
|
||||
compressedSize);
|
||||
} while ( mydata->m_ZLibStream.avail_out == 0 );
|
||||
} while ( mydata->ZLibStream.avail_out == 0 );
|
||||
|
||||
if ( !*mydata->OutputStream )
|
||||
{
|
||||
|
@ -146,7 +146,7 @@ ssize_t cmCPackTGZ_Data_Write(void *client_data, void *buff, size_t n)
|
|||
}
|
||||
if ( n )
|
||||
{
|
||||
mydata->m_CRC = crc32(mydata->m_CRC, reinterpret_cast<Bytef *>(buff), n);
|
||||
mydata->CRC = crc32(mydata->CRC, reinterpret_cast<Bytef *>(buff), n);
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
@ -160,19 +160,19 @@ int cmCPackTGZ_Data_Close(void *client_data)
|
|||
|
||||
char buffer[8];
|
||||
int n;
|
||||
uLong x = mydata->m_CRC;
|
||||
uLong x = mydata->CRC;
|
||||
for (n = 0; n < 4; n++) {
|
||||
buffer[n] = (int)(x & 0xff);
|
||||
x >>= 8;
|
||||
}
|
||||
x = mydata->m_ZLibStream.total_in;
|
||||
x = mydata->ZLibStream.total_in;
|
||||
for (n = 0; n < 4; n++) {
|
||||
buffer[n+4] = (int)(x & 0xff);
|
||||
x >>= 8;
|
||||
}
|
||||
|
||||
mydata->OutputStream->write(buffer, 8);
|
||||
(void)deflateEnd(&mydata->m_ZLibStream);
|
||||
(void)deflateEnd(&mydata->ZLibStream);
|
||||
delete mydata->OutputStream;
|
||||
mydata->OutputStream = 0;
|
||||
return (0);
|
||||
|
@ -204,7 +204,7 @@ int cmCPackTGZGenerator::CompressFiles(const char* outFileName,
|
|||
if (tar_open(&t, realName,
|
||||
&gztype,
|
||||
flags, 0644,
|
||||
(m_GeneratorVerbose?TAR_VERBOSE:0)
|
||||
(this->GeneratorVerbose?TAR_VERBOSE:0)
|
||||
| 0) == -1)
|
||||
{
|
||||
cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem with tar_open(): "
|
||||
|
|
|
@ -105,8 +105,8 @@ int cpackUnknownArgument(const char*, void*)
|
|||
struct cpackDefinitions
|
||||
{
|
||||
typedef std::map<cmStdString, cmStdString> MapType;
|
||||
MapType m_Map;
|
||||
cmCPackLog *m_Log;
|
||||
MapType Map;
|
||||
cmCPackLog *Log;
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
@ -119,14 +119,14 @@ int cpackDefinitionArgument(const char* argument, const char* cValue,
|
|||
size_t pos = value.find_first_of("=");
|
||||
if ( pos == std::string::npos )
|
||||
{
|
||||
cmCPack_Log(def->m_Log, cmCPackLog::LOG_ERROR,
|
||||
cmCPack_Log(def->Log, cmCPackLog::LOG_ERROR,
|
||||
"Please specify CPack definitions as: KEY=VALUE" << std::endl);
|
||||
return 0;
|
||||
}
|
||||
std::string key = value.substr(0, pos);
|
||||
value = value.c_str() + pos + 1;
|
||||
def->m_Map[key] = value;
|
||||
cmCPack_Log(def->m_Log, cmCPackLog::LOG_DEBUG, "Set CPack variable: "
|
||||
def->Map[key] = value;
|
||||
cmCPack_Log(def->Log, cmCPackLog::LOG_DEBUG, "Set CPack variable: "
|
||||
<< key.c_str() << " to \"" << value.c_str() << "\"" << std::endl);
|
||||
return 1;
|
||||
}
|
||||
|
@ -168,7 +168,7 @@ int main (int argc, char *argv[])
|
|||
std::string cpackConfigFile;
|
||||
|
||||
cpackDefinitions definitions;
|
||||
definitions.m_Log = &log;
|
||||
definitions.Log = &log;
|
||||
|
||||
cpackConfigFile = "";
|
||||
|
||||
|
@ -296,8 +296,8 @@ int main (int argc, char *argv[])
|
|||
mf->AddDefinition("CPACK_BUILD_CONFIG", cpackBuildConfig.c_str());
|
||||
}
|
||||
cpackDefinitions::MapType::iterator cdit;
|
||||
for ( cdit = definitions.m_Map.begin();
|
||||
cdit != definitions.m_Map.end();
|
||||
for ( cdit = definitions.Map.begin();
|
||||
cdit != definitions.Map.end();
|
||||
++cdit )
|
||||
{
|
||||
mf->AddDefinition(cdit->first.c_str(), cdit->second.c_str());
|
||||
|
|
|
@ -19,7 +19,8 @@
|
|||
#include "cmTarget.h"
|
||||
|
||||
// cmAddCustomCommandCommand
|
||||
bool cmAddCustomCommandCommand::InitialPass(std::vector<std::string> const& args)
|
||||
bool cmAddCustomCommandCommand::InitialPass(
|
||||
std::vector<std::string> const& args)
|
||||
{
|
||||
/* Let's complain at the end of this function about the lack of a particular
|
||||
arg. For the moment, let's say that COMMAND, and either TARGET or SOURCE
|
||||
|
@ -198,7 +199,8 @@ bool cmAddCustomCommandCommand::InitialPass(std::vector<std::string> const& args
|
|||
|
||||
if(source.empty() && !target.empty() && !output.empty())
|
||||
{
|
||||
this->SetError("Wrong syntax. A TARGET and OUTPUT can not both be specified.");
|
||||
this->SetError(
|
||||
"Wrong syntax. A TARGET and OUTPUT can not both be specified.");
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
|
@ -17,7 +17,8 @@
|
|||
#include "cmAddCustomTargetCommand.h"
|
||||
|
||||
// cmAddCustomTargetCommand
|
||||
bool cmAddCustomTargetCommand::InitialPass(std::vector<std::string> const& args)
|
||||
bool cmAddCustomTargetCommand::InitialPass(
|
||||
std::vector<std::string> const& args)
|
||||
{
|
||||
if(args.size() < 1 )
|
||||
{
|
||||
|
|
|
@ -17,7 +17,8 @@
|
|||
#include "cmAddDefinitionsCommand.h"
|
||||
|
||||
// cmAddDefinitionsCommand
|
||||
bool cmAddDefinitionsCommand::InitialPass(std::vector<std::string> const& args)
|
||||
bool cmAddDefinitionsCommand::InitialPass(
|
||||
std::vector<std::string> const& args)
|
||||
{
|
||||
// it is OK to have no arguments
|
||||
if(args.size() < 1 )
|
||||
|
|
|
@ -22,8 +22,8 @@
|
|||
/** \class cmAddDefinitionsCommand
|
||||
* \brief Specify a list of compiler defines
|
||||
*
|
||||
* cmAddDefinitionsCommand specifies a list of compiler defines. These defines will
|
||||
* be added to the compile command.
|
||||
* cmAddDefinitionsCommand specifies a list of compiler defines. These defines
|
||||
* will be added to the compile command.
|
||||
*/
|
||||
class cmAddDefinitionsCommand : public cmCommand
|
||||
{
|
||||
|
|
|
@ -17,7 +17,8 @@
|
|||
#include "cmAddDependenciesCommand.h"
|
||||
|
||||
// cmDependenciesCommand
|
||||
bool cmAddDependenciesCommand::InitialPass(std::vector<std::string> const& args)
|
||||
bool cmAddDependenciesCommand::InitialPass(
|
||||
std::vector<std::string> const& args)
|
||||
{
|
||||
if(args.size() < 2 )
|
||||
{
|
||||
|
|
|
@ -52,7 +52,8 @@ public:
|
|||
*/
|
||||
virtual const char* GetTerseDocumentation()
|
||||
{
|
||||
return "Add an executable to the project using the specified source files.";
|
||||
return
|
||||
"Add an executable to the project using the specified source files.";
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -68,15 +69,15 @@ public:
|
|||
"specified.\n"
|
||||
"After specifying the executable name, WIN32 and/or MACOSX_BUNDLE can "
|
||||
"be specified. WIN32 indicates that the executable (when compiled on "
|
||||
"windows) is a windows app (using WinMain) not a console app (using main). "
|
||||
"The variable CMAKE_MFC_FLAG be used if the windows app uses MFC. "
|
||||
"This variable can be set to the following values:\n"
|
||||
"windows) is a windows app (using WinMain) not a console app "
|
||||
"(using main). The variable CMAKE_MFC_FLAG be used if the windows app "
|
||||
"uses MFC. This variable can be set to the following values:\n"
|
||||
" 0: Use Standard Windows Libraries\n"
|
||||
" 1: Use MFC in a Static Library \n"
|
||||
" 2: Use MFC in a Shared DLL \n"
|
||||
"MACOSX_BUNDLE indicates that when build on Mac OSX, executable should "
|
||||
"be in the bundle form. The MACOSX_BUNDLE also allows several variables "
|
||||
"to be specified:\n"
|
||||
"be in the bundle form. The MACOSX_BUNDLE also allows several "
|
||||
"variables to be specified:\n"
|
||||
" MACOSX_BUNDLE_INFO_STRING\n"
|
||||
" MACOSX_BUNDLE_ICON_FILE\n"
|
||||
" MACOSX_BUNDLE_GUI_IDENTIFIER\n"
|
||||
|
|
|
@ -32,7 +32,8 @@ bool cmBuildCommand::InitialPass(std::vector<std::string> const& args)
|
|||
= m_Makefile->GetDefinition(define);
|
||||
std::string makeprogram = args[1];
|
||||
std::string makecommand
|
||||
= m_Makefile->GetLocalGenerator()->GetGlobalGenerator()->GenerateBuildCommand(
|
||||
= m_Makefile->GetLocalGenerator()
|
||||
->GetGlobalGenerator()->GenerateBuildCommand(
|
||||
makeprogram.c_str(), m_Makefile->GetProjectName(), 0,
|
||||
0, "Release", true);
|
||||
|
||||
|
|
|
@ -56,7 +56,8 @@ public:
|
|||
*/
|
||||
virtual const char* GetTerseDocumentation()
|
||||
{
|
||||
return "Deprecated. Use ${CMAKE_SYSTEM} and ${CMAKE_CXX_COMPILER} instead.";
|
||||
return
|
||||
"Deprecated. Use ${CMAKE_SYSTEM} and ${CMAKE_CXX_COMPILER} instead.";
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
@ -67,7 +67,8 @@ bool cmCMakeMinimumRequired::InitialPass(std::vector<std::string> const& args)
|
|||
}
|
||||
|
||||
// Save the required version string.
|
||||
m_Makefile->AddDefinition("CMAKE_MINIMUM_REQUIRED_VERSION", version_string.c_str());
|
||||
m_Makefile->AddDefinition("CMAKE_MINIMUM_REQUIRED_VERSION",
|
||||
version_string.c_str());
|
||||
|
||||
// Get the current version number.
|
||||
int current_major = m_Makefile->GetMajorVersion();
|
||||
|
@ -102,9 +103,11 @@ bool cmCMakeMinimumRequired::InitialPass(std::vector<std::string> const& args)
|
|||
{
|
||||
e << "WARNING: ";
|
||||
}
|
||||
e << "This project requires version " << version_string.c_str() << " of CMake. "
|
||||
e << "This project requires version " << version_string.c_str()
|
||||
<< " of CMake. "
|
||||
<< "You are running version "
|
||||
<< current_major << "." << current_minor << "." << current_patch << ".\n";
|
||||
<< current_major << "." << current_minor << "." << current_patch
|
||||
<< ".\n";
|
||||
if(fatal_error)
|
||||
{
|
||||
cmSystemTools::Error(e.str().c_str());
|
||||
|
|
|
@ -74,9 +74,8 @@ void CCONV cmAddDefinition(void *arg, const char* name, const char* value)
|
|||
}
|
||||
|
||||
/* Add a definition to this makefile and the global cmake cache. */
|
||||
void CCONV cmAddCacheDefinition(void *arg, const char* name, const char* value,
|
||||
const char* doc,
|
||||
int type)
|
||||
void CCONV cmAddCacheDefinition(void *arg, const char* name,
|
||||
const char* value, const char* doc, int type)
|
||||
{
|
||||
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
||||
|
||||
|
@ -170,7 +169,8 @@ void CCONV cmAddDefineFlag(void *arg, const char* definition)
|
|||
mf->AddDefineFlag(definition);
|
||||
}
|
||||
|
||||
void CCONV cmAddLinkDirectoryForTarget(void *arg, const char *tgt, const char* d)
|
||||
void CCONV cmAddLinkDirectoryForTarget(void *arg, const char *tgt,
|
||||
const char* d)
|
||||
{
|
||||
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
||||
mf->AddLinkDirectoryForTarget(tgt,d);
|
||||
|
@ -368,8 +368,8 @@ void CCONV cmAddCustomCommandToTarget(void *arg, const char* target,
|
|||
cctype, no_comment, no_working_dir);
|
||||
}
|
||||
|
||||
void CCONV cmAddLinkLibraryForTarget(void *arg, const char *tgt, const char*value,
|
||||
int libtype)
|
||||
void CCONV cmAddLinkLibraryForTarget(void *arg, const char *tgt,
|
||||
const char*value, int libtype)
|
||||
{
|
||||
cmMakefile *mf = static_cast<cmMakefile *>(arg);
|
||||
|
||||
|
@ -540,7 +540,8 @@ int CCONV cmSourceFileGetPropertyAsBool(void *arg,const char *prop)
|
|||
return (sf->GetPropertyAsBool(prop) ? 1: 0);
|
||||
}
|
||||
|
||||
void CCONV cmSourceFileSetProperty(void *arg,const char *prop, const char *val)
|
||||
void CCONV cmSourceFileSetProperty(void *arg,const char *prop,
|
||||
const char *val)
|
||||
{
|
||||
cmSourceFile *sf = static_cast<cmSourceFile *>(arg);
|
||||
sf->SetProperty(prop,val);
|
||||
|
|
|
@ -78,7 +78,8 @@ typedef struct
|
|||
int numOutputs, const char **outputs,
|
||||
const char *target);
|
||||
void (CCONV *AddDefineFlag) (void *mf, const char* definition);
|
||||
void (CCONV *AddDefinition) (void *mf, const char* name, const char* value);
|
||||
void (CCONV *AddDefinition) (void *mf, const char* name,
|
||||
const char* value);
|
||||
void (CCONV *AddExecutable) (void *mf, const char *exename,
|
||||
int numSrcs, const char **srcs, int win32);
|
||||
void (CCONV *AddLibrary) (void *mf, const char *libname,
|
||||
|
@ -94,7 +95,8 @@ typedef struct
|
|||
int (CCONV *CommandExists) (void *mf, const char* name);
|
||||
int (CCONV *ExecuteCommand) (void *mf, const char *name,
|
||||
int numArgs, const char **args);
|
||||
void (CCONV *ExpandSourceListArguments) (void *mf,int argc, const char **argv,
|
||||
void (CCONV *ExpandSourceListArguments) (void *mf,int argc,
|
||||
const char **argv,
|
||||
int *resArgc, char ***resArgv,
|
||||
unsigned int startArgumentIndex);
|
||||
char *(CCONV *ExpandVariablesInString) (void *mf, const char *source,
|
||||
|
@ -128,12 +130,14 @@ typedef struct
|
|||
int (CCONV *SourceFileGetPropertyAsBool) (void *sf, const char *prop);
|
||||
const char *(CCONV *SourceFileGetSourceName) (void *sf);
|
||||
const char *(CCONV *SourceFileGetFullPath) (void *sf);
|
||||
void (CCONV *SourceFileSetName) (void *sf, const char* name, const char* dir,
|
||||
void (CCONV *SourceFileSetName) (void *sf, const char* name,
|
||||
const char* dir,
|
||||
int numSourceExtensions,
|
||||
const char **sourceExtensions,
|
||||
int numHeaderExtensions,
|
||||
const char **headerExtensions);
|
||||
void (CCONV *SourceFileSetName2) (void *sf, const char* name, const char* dir,
|
||||
void (CCONV *SourceFileSetName2) (void *sf, const char* name,
|
||||
const char* dir,
|
||||
const char *ext, int headerFileOnly);
|
||||
void (CCONV *SourceFileSetProperty) (void *sf, const char *prop,
|
||||
const char *value);
|
||||
|
|
|
@ -85,9 +85,11 @@ bool cmCacheManager::ParseEntry(const char* entry,
|
|||
std::string& value)
|
||||
{
|
||||
// input line is: key:type=value
|
||||
static cmsys::RegularExpression reg("^([^:]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$");
|
||||
static cmsys::RegularExpression reg(
|
||||
"^([^:]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$");
|
||||
// input line is: "key":type=value
|
||||
static cmsys::RegularExpression regQuoted("^\"([^\"]*)\"=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$");
|
||||
static cmsys::RegularExpression regQuoted(
|
||||
"^\"([^\"]*)\"=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$");
|
||||
bool flag = false;
|
||||
if(regQuoted.find(entry))
|
||||
{
|
||||
|
@ -122,9 +124,11 @@ bool cmCacheManager::ParseEntry(const char* entry,
|
|||
CacheEntryType& type)
|
||||
{
|
||||
// input line is: key:type=value
|
||||
static cmsys::RegularExpression reg("^([^:]*):([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$");
|
||||
static cmsys::RegularExpression reg(
|
||||
"^([^:]*):([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$");
|
||||
// input line is: "key":type=value
|
||||
static cmsys::RegularExpression regQuoted("^\"([^\"]*)\":([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$");
|
||||
static cmsys::RegularExpression regQuoted(
|
||||
"^\"([^\"]*)\":([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$");
|
||||
bool flag = false;
|
||||
if(regQuoted.find(entry))
|
||||
{
|
||||
|
@ -250,12 +254,14 @@ bool cmCacheManager::LoadCache(const char* path,
|
|||
}
|
||||
if ( e.m_Type == cmCacheManager::INTERNAL &&
|
||||
(entryKey.size() > strlen("-ADVANCED")) &&
|
||||
strcmp(entryKey.c_str() + (entryKey.size() - strlen("-ADVANCED")),
|
||||
"-ADVANCED") == 0 )
|
||||
strcmp(entryKey.c_str() + (entryKey.size() -
|
||||
strlen("-ADVANCED")), "-ADVANCED") == 0 )
|
||||
{
|
||||
std::string value = e.m_Value;
|
||||
std::string akey = entryKey.substr(0, (entryKey.size() - strlen("-ADVANCED")));
|
||||
cmCacheManager::CacheIterator it = this->GetCacheIterator(akey.c_str());
|
||||
std::string akey
|
||||
= entryKey.substr(0, (entryKey.size() - strlen("-ADVANCED")));
|
||||
cmCacheManager::CacheIterator it
|
||||
= this->GetCacheIterator(akey.c_str());
|
||||
if ( it.IsAtEnd() )
|
||||
{
|
||||
e.m_Type = cmCacheManager::UNINITIALIZED;
|
||||
|
@ -269,12 +275,14 @@ bool cmCacheManager::LoadCache(const char* path,
|
|||
}
|
||||
else if ( e.m_Type == cmCacheManager::INTERNAL &&
|
||||
(entryKey.size() > strlen("-MODIFIED")) &&
|
||||
strcmp(entryKey.c_str() + (entryKey.size() - strlen("-MODIFIED")),
|
||||
"-MODIFIED") == 0 )
|
||||
strcmp(entryKey.c_str() + (entryKey.size() -
|
||||
strlen("-MODIFIED")), "-MODIFIED") == 0 )
|
||||
{
|
||||
std::string value = e.m_Value;
|
||||
std::string akey = entryKey.substr(0, (entryKey.size() - strlen("-MODIFIED")));
|
||||
cmCacheManager::CacheIterator it = this->GetCacheIterator(akey.c_str());
|
||||
std::string akey
|
||||
= entryKey.substr(0, (entryKey.size() - strlen("-MODIFIED")));
|
||||
cmCacheManager::CacheIterator it
|
||||
= this->GetCacheIterator(akey.c_str());
|
||||
if ( it.IsAtEnd() )
|
||||
{
|
||||
e.m_Type = cmCacheManager::UNINITIALIZED;
|
||||
|
@ -368,7 +376,8 @@ bool cmCacheManager::SaveCache(const char* path)
|
|||
"Major version of cmake used to create the "
|
||||
"current loaded cache", cmCacheManager::INTERNAL);
|
||||
|
||||
this->AddCacheEntry("CMAKE_CACHE_RELEASE_VERSION", cmMakefile::GetReleaseVersion(),
|
||||
this->AddCacheEntry("CMAKE_CACHE_RELEASE_VERSION",
|
||||
cmMakefile::GetReleaseVersion(),
|
||||
"Major version of cmake used to create the "
|
||||
"current loaded cache", cmCacheManager::INTERNAL);
|
||||
|
||||
|
@ -387,19 +396,25 @@ bool cmCacheManager::SaveCache(const char* path)
|
|||
|
||||
fout << "# This is the CMakeCache file.\n"
|
||||
<< "# For build in directory: " << currentcwd << "\n";
|
||||
cmCacheManager::CacheEntry* cmakeCacheEntry = this->GetCacheEntry("CMAKE_COMMAND");
|
||||
cmCacheManager::CacheEntry* cmakeCacheEntry
|
||||
= this->GetCacheEntry("CMAKE_COMMAND");
|
||||
if ( cmakeCacheEntry )
|
||||
{
|
||||
fout << "# It was generated by CMake: " << cmakeCacheEntry->m_Value << std::endl;
|
||||
fout << "# It was generated by CMake: " << cmakeCacheEntry->m_Value
|
||||
<< std::endl;
|
||||
}
|
||||
|
||||
fout << "# You can edit this file to change values found and used by cmake.\n"
|
||||
<< "# If you do not want to change any of the values, simply exit the editor.\n"
|
||||
<< "# If you do want to change a value, simply edit, save, and exit the editor.\n"
|
||||
fout << "# You can edit this file to change values found and used by cmake."
|
||||
<< std::endl
|
||||
<< "# If you do not want to change any of the values, simply exit the "
|
||||
"editor." << std::endl
|
||||
<< "# If you do want to change a value, simply edit, save, and exit "
|
||||
"the editor." << std::endl
|
||||
<< "# The syntax for the file is as follows:\n"
|
||||
<< "# KEY:TYPE=VALUE\n"
|
||||
<< "# KEY is the name of a variable in the cache.\n"
|
||||
<< "# TYPE is a hint to GUI's for the type of VALUE, DO NOT EDIT TYPE!.\n"
|
||||
<< "# TYPE is a hint to GUI's for the type of VALUE, DO NOT EDIT "
|
||||
"TYPE!." << std::endl
|
||||
<< "# VALUE is the current value for the KEY.\n\n";
|
||||
|
||||
fout << "########################\n";
|
||||
|
@ -595,7 +610,8 @@ bool cmCacheManager::SaveCache(const char* path)
|
|||
checkCacheFile.c_str());
|
||||
return false;
|
||||
}
|
||||
checkCache << "# This file is generated by cmake for dependency checking of the CMakeCache.txt file\n";
|
||||
checkCache << "# This file is generated by cmake for dependency checking "
|
||||
"of the CMakeCache.txt file\n";
|
||||
return true;
|
||||
}
|
||||
|
||||
|
@ -611,7 +627,9 @@ bool cmCacheManager::DeleteCache(const char* path)
|
|||
cmsys::Directory dir;
|
||||
cmakeFiles += "/CMakeFiles";
|
||||
dir.Load(cmakeFiles.c_str());
|
||||
for (unsigned long fileNum = 0; fileNum < dir.GetNumberOfFiles(); ++fileNum)
|
||||
for (unsigned long fileNum = 0;
|
||||
fileNum < dir.GetNumberOfFiles();
|
||||
++fileNum)
|
||||
{
|
||||
if(!cmSystemTools::
|
||||
FileIsDirectory(dir.GetFile(fileNum)))
|
||||
|
@ -683,7 +701,8 @@ cmCacheManager::CacheEntry *cmCacheManager::GetCacheEntry(const char* key)
|
|||
return 0;
|
||||
}
|
||||
|
||||
cmCacheManager::CacheIterator cmCacheManager::GetCacheIterator(const char *key)
|
||||
cmCacheManager::CacheIterator cmCacheManager::GetCacheIterator(
|
||||
const char *key)
|
||||
{
|
||||
return CacheIterator(*this, key);
|
||||
}
|
||||
|
@ -709,11 +728,13 @@ void cmCacheManager::PrintCache(std::ostream& out) const
|
|||
{
|
||||
if((*i).second.m_Type != INTERNAL)
|
||||
{
|
||||
out << (*i).first.c_str() << " = " << (*i).second.m_Value.c_str() << std::endl;
|
||||
out << (*i).first.c_str() << " = " << (*i).second.m_Value.c_str()
|
||||
<< std::endl;
|
||||
}
|
||||
}
|
||||
out << "\n\n";
|
||||
out << "To change values in the CMakeCache, \nedit CMakeCache.txt in your output directory.\n";
|
||||
out << "To change values in the CMakeCache, "
|
||||
<< std::endl << "edit CMakeCache.txt in your output directory.\n";
|
||||
out << "=================================================" << std::endl;
|
||||
}
|
||||
|
||||
|
@ -745,7 +766,8 @@ void cmCacheManager::AddCacheEntry(const char* key,
|
|||
}
|
||||
else
|
||||
{
|
||||
e.m_Properties["HELPSTRING"] = "(This variable does not exists and should not be used)";
|
||||
e.m_Properties["HELPSTRING"]
|
||||
= "(This variable does not exists and should not be used)";
|
||||
}
|
||||
m_Cache[key] = e;
|
||||
}
|
||||
|
@ -805,7 +827,8 @@ void cmCacheManager::CacheIterator::SetValue(const char* value)
|
|||
}
|
||||
}
|
||||
|
||||
const char* cmCacheManager::CacheIterator::GetProperty(const char* property) const
|
||||
const char* cmCacheManager::CacheIterator::GetProperty(
|
||||
const char* property) const
|
||||
{
|
||||
// make sure it is not at the end
|
||||
if (this->IsAtEnd())
|
||||
|
@ -852,7 +875,8 @@ bool cmCacheManager::CacheIterator::GetValueAsBool() const
|
|||
return cmSystemTools::IsOn(this->GetEntry().m_Value.c_str());
|
||||
}
|
||||
|
||||
bool cmCacheManager::CacheIterator::GetPropertyAsBool(const char* property) const
|
||||
bool cmCacheManager::CacheIterator::GetPropertyAsBool(
|
||||
const char* property) const
|
||||
{
|
||||
// make sure it is not at the end
|
||||
if (this->IsAtEnd())
|
||||
|
|
|
@ -1,7 +1,8 @@
|
|||
/* A Bison parser, made by GNU Bison 1.875d. */
|
||||
|
||||
/* Skeleton parser for Yacc-like parsing with Bison,
|
||||
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
|
||||
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software
|
||||
Foundation, Inc.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
|
@ -115,7 +116,9 @@ This file must be translated to C and modified to build everywhere.
|
|||
|
||||
Run bison like this:
|
||||
|
||||
bison --yacc --name-prefix=cmCommandArgument_yy --defines=cmCommandArgumentParserTokens.h -ocmCommandArgumentParser.cxx cmCommandArgumentParser.y
|
||||
bison --yacc --name-prefix=cmCommandArgument_yy \
|
||||
--defines=cmCommandArgumentParserTokens.h \
|
||||
-ocmCommandArgumentParser.cxx cmCommandArgumentParser.y
|
||||
|
||||
Modify cmCommandArgumentParser.cxx:
|
||||
- remove TABs
|
||||
|
@ -153,7 +156,7 @@ static void cmCommandArgumentError(yyscan_t yyscanner, const char* message);
|
|||
#endif
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning (disable: 4102) /* Unused goto label. */
|
||||
# pragma warning (disable: 4065) /* Switch statement contains default but no case. */
|
||||
# pragma warning (disable: 4065) /* Switch contains default but no case. */
|
||||
#endif
|
||||
|
||||
|
||||
|
@ -1171,7 +1174,6 @@ yyreduce:
|
|||
|
||||
{
|
||||
yyval.str = yyGetParser->ExpandSpecialVariable(yyvsp[-2].str,yyvsp[-1].str);
|
||||
//std::cerr << __LINE__ << " here: [" << $<str>1 << "] [" << $<str>2 << "] [" << $<str>3 << "]" << std::endl;
|
||||
}
|
||||
break;
|
||||
|
||||
|
@ -1179,7 +1181,6 @@ yyreduce:
|
|||
|
||||
{
|
||||
yyval.str = yyGetParser->ExpandVariable(yyvsp[-1].str);
|
||||
//std::cerr << __LINE__ << " here: [" << $<str>1 << "] [" << $<str>2 << "] [" << $<str>3 << "]" << std::endl;
|
||||
}
|
||||
break;
|
||||
|
||||
|
|
|
@ -22,7 +22,8 @@
|
|||
#define YYSTYPE cmCommandArgumentParserHelper::ParserType
|
||||
#define YYSTYPE_IS_DECLARED
|
||||
#define YY_EXTRA_TYPE cmCommandArgumentParserHelper*
|
||||
#define YY_DECL int cmCommandArgument_yylex(YYSTYPE* yylvalp, yyscan_t yyscanner)
|
||||
#define YY_DECL int cmCommandArgument_yylex(YYSTYPE* yylvalp,\
|
||||
yyscan_t yyscanner)
|
||||
|
||||
/** \class cmCommandArgumentParserHelper
|
||||
* \brief Helper class for parsing java source files
|
||||
|
@ -47,7 +48,8 @@ public:
|
|||
// For the lexer:
|
||||
void AllocateParserType(cmCommandArgumentParserHelper::ParserType* pt,
|
||||
const char* str, int len = 0);
|
||||
bool HandleEscapeSymbol(cmCommandArgumentParserHelper::ParserType* pt, char symbol);
|
||||
bool HandleEscapeSymbol(cmCommandArgumentParserHelper::ParserType* pt,
|
||||
char symbol);
|
||||
|
||||
int LexInput(char* buf, int maxlen);
|
||||
void Error(const char* str);
|
||||
|
|
|
@ -1,7 +1,8 @@
|
|||
/* A Bison parser, made by GNU Bison 1.875d. */
|
||||
|
||||
/* Skeleton parser for Yacc-like parsing with Bison,
|
||||
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
|
||||
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software
|
||||
Foundation, Inc.
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
|
|
|
@ -73,7 +73,8 @@ bool cmCreateTestSourceList::InitialPass(std::vector<std::string> const& args)
|
|||
// make sure they specified an extension
|
||||
if (cmSystemTools::GetFilenameExtension(*i).size() < 2)
|
||||
{
|
||||
this->SetError("You must specify a file extenion for the test driver file.");
|
||||
this->SetError(
|
||||
"You must specify a file extenion for the test driver file.");
|
||||
return false;
|
||||
}
|
||||
std::string driver = m_Makefile->GetCurrentOutputDirectory();
|
||||
|
@ -149,16 +150,21 @@ bool cmCreateTestSourceList::InitialPass(std::vector<std::string> const& args)
|
|||
}
|
||||
if(extraInclude.size())
|
||||
{
|
||||
m_Makefile->AddDefinition("CMAKE_TESTDRIVER_EXTRA_INCLUDES", extraInclude.c_str());
|
||||
m_Makefile->AddDefinition("CMAKE_TESTDRIVER_EXTRA_INCLUDES",
|
||||
extraInclude.c_str());
|
||||
}
|
||||
if(function.size())
|
||||
{
|
||||
m_Makefile->AddDefinition("CMAKE_TESTDRIVER_ARGVC_FUNCTION", function.c_str());
|
||||
m_Makefile->AddDefinition("CMAKE_TESTDRIVER_ARGVC_FUNCTION",
|
||||
function.c_str());
|
||||
}
|
||||
m_Makefile->AddDefinition("CMAKE_FORWARD_DECLARE_TESTS", forwardDeclareCode.c_str());
|
||||
m_Makefile->AddDefinition("CMAKE_FUNCTION_TABLE_ENTIRES", functionMapCode.c_str());
|
||||
m_Makefile->AddDefinition("CMAKE_FORWARD_DECLARE_TESTS",
|
||||
forwardDeclareCode.c_str());
|
||||
m_Makefile->AddDefinition("CMAKE_FUNCTION_TABLE_ENTIRES",
|
||||
functionMapCode.c_str());
|
||||
bool res = true;
|
||||
if ( !m_Makefile->ConfigureFile(configFile.c_str(), driver.c_str(), false, true, false) )
|
||||
if ( !m_Makefile->ConfigureFile(configFile.c_str(), driver.c_str(),
|
||||
false, true, false) )
|
||||
{
|
||||
res = false;
|
||||
}
|
||||
|
|
|
@ -37,7 +37,8 @@ cmCustomCommand::cmCustomCommand(const cmCustomCommand& r):
|
|||
cmCustomCommand::cmCustomCommand(const char* output,
|
||||
const std::vector<std::string>& depends,
|
||||
const cmCustomCommandLines& commandLines,
|
||||
const char* comment, const char* workingDirectory):
|
||||
const char* comment,
|
||||
const char* workingDirectory):
|
||||
m_Output(output?output:""),
|
||||
m_Depends(depends),
|
||||
m_CommandLines(commandLines),
|
||||
|
|
|
@ -48,7 +48,8 @@ cmDependsC::~cmDependsC()
|
|||
{
|
||||
this->WriteCacheFile();
|
||||
|
||||
for (std::map<cmStdString, cmIncludeLines*>::iterator it=m_fileCache.begin();
|
||||
for (std::map<cmStdString, cmIncludeLines*>::iterator it
|
||||
= m_fileCache.begin();
|
||||
it!=m_fileCache.end(); ++it)
|
||||
{
|
||||
delete it->second;
|
||||
|
@ -154,7 +155,8 @@ bool cmDependsC::WriteDependencies(const char *src, const char *obj,
|
|||
scanned.insert(fullName);
|
||||
|
||||
// Check whether this file is already in the cache
|
||||
std::map<cmStdString, cmIncludeLines*>::iterator fileIt=m_fileCache.find(fullName);
|
||||
std::map<cmStdString, cmIncludeLines*>::iterator fileIt
|
||||
= m_fileCache.find(fullName);
|
||||
if (fileIt!=m_fileCache.end())
|
||||
{
|
||||
fileIt->second->m_Used=true;
|
||||
|
@ -238,7 +240,8 @@ void cmDependsC::ReadCacheFile()
|
|||
haveFileName=true;
|
||||
int newer=0;
|
||||
cmFileTimeComparison comp;
|
||||
bool res=comp.FileTimeCompare(m_cacheFileName.c_str(), line.c_str(), &newer);
|
||||
bool res
|
||||
= comp.FileTimeCompare(m_cacheFileName.c_str(), line.c_str(), &newer);
|
||||
|
||||
if ((res==true) && (newer==1)) //cache is newer than the parsed file
|
||||
{
|
||||
|
@ -275,7 +278,8 @@ void cmDependsC::WriteCacheFile() const
|
|||
return;
|
||||
}
|
||||
|
||||
for (std::map<cmStdString, cmIncludeLines*>::const_iterator fileIt=m_fileCache.begin();
|
||||
for (std::map<cmStdString, cmIncludeLines*>::const_iterator fileIt
|
||||
= m_fileCache.begin();
|
||||
fileIt!=m_fileCache.end(); ++fileIt)
|
||||
{
|
||||
if (fileIt->second->m_Used)
|
||||
|
@ -302,7 +306,8 @@ void cmDependsC::WriteCacheFile() const
|
|||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void cmDependsC::Scan(std::istream& is, const char* directory, const cmStdString& fullName)
|
||||
void cmDependsC::Scan(std::istream& is, const char* directory,
|
||||
const cmStdString& fullName)
|
||||
{
|
||||
cmIncludeLines* newCacheEntry=new cmIncludeLines;
|
||||
newCacheEntry->m_Used=true;
|
||||
|
|
|
@ -32,7 +32,8 @@ public:
|
|||
cmDependsC();
|
||||
cmDependsC(std::vector<std::string> const& includes,
|
||||
const char* scanRegex, const char* complainRegex,
|
||||
std::set<cmStdString> const& generatedFiles, const cmStdString& cachFileName);
|
||||
std::set<cmStdString> const& generatedFiles,
|
||||
const cmStdString& cachFileName);
|
||||
|
||||
/** Virtual destructor to cleanup subclasses properly. */
|
||||
virtual ~cmDependsC();
|
||||
|
@ -47,7 +48,8 @@ protected:
|
|||
std::ostream& internalDepends);
|
||||
|
||||
// Method to scan a single file.
|
||||
void Scan(std::istream& is, const char* directory, const cmStdString& fullName);
|
||||
void Scan(std::istream& is, const char* directory,
|
||||
const cmStdString& fullName);
|
||||
|
||||
// Method to test for the existence of a file.
|
||||
bool FileExistsOrIsGenerated(const std::string& fname,
|
||||
|
|
|
@ -165,7 +165,8 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE;
|
|||
|
||||
#define YY_LESS_LINENO(n)
|
||||
|
||||
/* Return all but the first "n" matched characters back to the input stream. */
|
||||
/* Return all but the first "n" matched characters back to the input stream.
|
||||
*/
|
||||
#define yyless(n) \
|
||||
do \
|
||||
{ \
|
||||
|
@ -174,7 +175,8 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE;
|
|||
YY_LESS_LINENO(yyless_macro_arg);\
|
||||
*yy_cp = yyg->yy_hold_char; \
|
||||
YY_RESTORE_YY_MORE_OFFSET \
|
||||
yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
|
||||
yyg->yy_c_buf_p \
|
||||
= yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
|
||||
YY_DO_BEFORE_ACTION; /* set up yytext again */ \
|
||||
} \
|
||||
while ( 0 )
|
||||
|
@ -248,8 +250,8 @@ struct yy_buffer_state
|
|||
* possible backing-up.
|
||||
*
|
||||
* When we actually see the EOF, we change the status to "new"
|
||||
* (via cmDependsFortran_yyrestart()), so that the user can continue scanning by
|
||||
* just pointing yyin at a new input file.
|
||||
* (via cmDependsFortran_yyrestart()), so that the user can continue
|
||||
* scanning by just pointing yyin at a new input file.
|
||||
*/
|
||||
#define YY_BUFFER_EOF_PENDING 2
|
||||
|
||||
|
|
|
@ -185,16 +185,24 @@ struct yy_buffer_state
|
|||
#endif /* !YY_STRUCT_YY_BUFFER_STATE */
|
||||
|
||||
void cmDependsFortran_yyrestart (FILE *input_file ,yyscan_t yyscanner );
|
||||
void cmDependsFortran_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
|
||||
YY_BUFFER_STATE cmDependsFortran_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
|
||||
void cmDependsFortran_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
|
||||
void cmDependsFortran_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
|
||||
void cmDependsFortran_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
|
||||
void cmDependsFortran_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,
|
||||
yyscan_t yyscanner );
|
||||
YY_BUFFER_STATE cmDependsFortran_yy_create_buffer (FILE *file,int size ,
|
||||
yyscan_t yyscanner );
|
||||
void cmDependsFortran_yy_delete_buffer (YY_BUFFER_STATE b ,
|
||||
yyscan_t yyscanner );
|
||||
void cmDependsFortran_yy_flush_buffer (YY_BUFFER_STATE b ,
|
||||
yyscan_t yyscanner );
|
||||
void cmDependsFortran_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,
|
||||
yyscan_t yyscanner );
|
||||
void cmDependsFortran_yypop_buffer_state (yyscan_t yyscanner );
|
||||
|
||||
YY_BUFFER_STATE cmDependsFortran_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
|
||||
YY_BUFFER_STATE cmDependsFortran_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
|
||||
YY_BUFFER_STATE cmDependsFortran_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
|
||||
YY_BUFFER_STATE cmDependsFortran_yy_scan_buffer (char *base,yy_size_t size ,
|
||||
yyscan_t yyscanner );
|
||||
YY_BUFFER_STATE cmDependsFortran_yy_scan_string (yyconst char *yy_str ,
|
||||
yyscan_t yyscanner );
|
||||
YY_BUFFER_STATE cmDependsFortran_yy_scan_bytes (yyconst char *bytes,int len ,
|
||||
yyscan_t yyscanner );
|
||||
|
||||
void *cmDependsFortran_yyalloc (yy_size_t ,yyscan_t yyscanner );
|
||||
void *cmDependsFortran_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
|
||||
|
@ -231,7 +239,8 @@ void cmDependsFortran_yyset_debug (int debug_flag ,yyscan_t yyscanner );
|
|||
|
||||
YY_EXTRA_TYPE cmDependsFortran_yyget_extra (yyscan_t yyscanner );
|
||||
|
||||
void cmDependsFortran_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
|
||||
void cmDependsFortran_yyset_extra (YY_EXTRA_TYPE user_defined ,
|
||||
yyscan_t yyscanner );
|
||||
|
||||
FILE *cmDependsFortran_yyget_in (yyscan_t yyscanner );
|
||||
|
||||
|
@ -294,7 +303,8 @@ extern int cmDependsFortran_yylex (yyscan_t yyscanner);
|
|||
#define YY_DECL int cmDependsFortran_yylex (yyscan_t yyscanner)
|
||||
#endif /* !YY_DECL */
|
||||
|
||||
/* yy_get_previous_state - get the state just before the EOB char was reached */
|
||||
/* yy_get_previous_state - get the state just before the EOB char was reached
|
||||
*/
|
||||
|
||||
#undef YY_NEW_FILE
|
||||
#undef YY_FLUSH_BUFFER
|
||||
|
|
|
@ -273,7 +273,8 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf)
|
|||
f->m_Args = this->m_Args;
|
||||
f->m_Functions = this->m_Functions;
|
||||
std::string newName = "_" + this->m_Args[0];
|
||||
mf.GetCMakeInstance()->RenameCommand(this->m_Args[0].c_str(), newName.c_str());
|
||||
mf.GetCMakeInstance()->RenameCommand(
|
||||
this->m_Args[0].c_str(), newName.c_str());
|
||||
mf.AddCommand(f);
|
||||
|
||||
// remove the function blocker now that the macro is defined
|
||||
|
@ -308,7 +309,9 @@ void cmMacroFunctionBlocker::
|
|||
ScopeEnded(cmMakefile &mf)
|
||||
{
|
||||
// macros should end with an EndMacro
|
||||
cmSystemTools::Error("The end of a CMakeLists file was reached with a MACRO statement that was not closed properly. Within the directory: ",
|
||||
cmSystemTools::Error(
|
||||
"The end of a CMakeLists file was reached with a MACRO statement that "
|
||||
"was not closed properly. Within the directory: ",
|
||||
mf.GetCurrentDirectory(), " with macro ",
|
||||
m_Args[0].c_str());
|
||||
}
|
||||
|
|
|
@ -93,8 +93,8 @@ public:
|
|||
"arg1 arg2 arg3 (...). Commands listed after MACRO, "
|
||||
"but before the matching ENDMACRO, are not invoked until the macro "
|
||||
"is invoked. When it is invoked, the commands recorded in the "
|
||||
"macro are first modified by replacing formal parameters (${arg1}) with "
|
||||
"the arguments passed, and then invoked as normal commands. In "
|
||||
"macro are first modified by replacing formal parameters (${arg1}) "
|
||||
"with the arguments passed, and then invoked as normal commands. In "
|
||||
"addition to referencing the formal parameters you can reference "
|
||||
"the variable ARGC which will be set to the number of arguments "
|
||||
"passed into the function as well as ARGV0 ARGV1 ARGV2 ... which "
|
||||
|
|
|
@ -94,7 +94,8 @@ void cmMakeDepend::GenerateDependInformation(cmDependInformation* info)
|
|||
const char* path = info->m_FullPath.c_str();
|
||||
if(!path)
|
||||
{
|
||||
cmSystemTools::Error("Attempt to find dependencies for file without path!");
|
||||
cmSystemTools::Error(
|
||||
"Attempt to find dependencies for file without path!");
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -138,7 +139,8 @@ void cmMakeDepend::GenerateDependInformation(cmDependInformation* info)
|
|||
{
|
||||
// Try to find the file amongst the sources
|
||||
cmSourceFile *srcFile =
|
||||
m_Makefile->GetSource(cmSystemTools::GetFilenameWithoutExtension(path).c_str());
|
||||
m_Makefile->GetSource(
|
||||
cmSystemTools::GetFilenameWithoutExtension(path).c_str());
|
||||
if (srcFile)
|
||||
{
|
||||
if (srcFile->GetFullPath() == path)
|
||||
|
@ -189,7 +191,8 @@ void cmMakeDepend::GenerateDependInformation(cmDependInformation* info)
|
|||
// #include directives
|
||||
void cmMakeDepend::DependWalk(cmDependInformation* info)
|
||||
{
|
||||
cmsys::RegularExpression includeLine("^[ \t]*#[ \t]*include[ \t]*[<\"]([^\">]+)[\">]");
|
||||
cmsys::RegularExpression includeLine(
|
||||
"^[ \t]*#[ \t]*include[ \t]*[<\"]([^\">]+)[\">]");
|
||||
std::ifstream fin(info->m_FullPath.c_str());
|
||||
if(!fin)
|
||||
{
|
||||
|
|
165
Source/cmake.cxx
165
Source/cmake.cxx
|
@ -86,12 +86,14 @@ void cmNeedBackwardsCompatibility(const std::string& variable,
|
|||
{
|
||||
std::string message = "An attempt was made to access a variable: ";
|
||||
message += variable;
|
||||
message += " that has not been defined. Some variables were always defined "
|
||||
"by CMake in versions prior to 1.6. To fix this you might need to set the "
|
||||
"cache value of CMAKE_BACKWARDS_COMPATIBILITY to 1.4 or less. If you are "
|
||||
"writing a CMakeList file, (or have already set "
|
||||
"CMAKE_BACKWARDS_COMPATABILITY to 1.4 or less) then you probably need to "
|
||||
"include a CMake module to test for the feature this variable defines.";
|
||||
message +=
|
||||
" that has not been defined. Some variables were always defined "
|
||||
"by CMake in versions prior to 1.6. To fix this you might need to set "
|
||||
"the cache value of CMAKE_BACKWARDS_COMPATIBILITY to 1.4 or less. If "
|
||||
"you are writing a CMakeList file, (or have already set "
|
||||
"CMAKE_BACKWARDS_COMPATABILITY to 1.4 or less) then you probably need "
|
||||
"to include a CMake module to test for the feature this variable "
|
||||
"defines.";
|
||||
cmSystemTools::Error(message.c_str());
|
||||
}
|
||||
#else
|
||||
|
@ -520,7 +522,8 @@ void cmake::SetDirectoriesFromFile(const char* arg)
|
|||
{
|
||||
cmCacheManager* cachem = this->GetCacheManager();
|
||||
cmCacheManager::CacheIterator it = cachem->NewIterator();
|
||||
if(cachem->LoadCache(cachePath.c_str()) && it.Find("CMAKE_HOME_DIRECTORY"))
|
||||
if(cachem->LoadCache(cachePath.c_str()) &&
|
||||
it.Find("CMAKE_HOME_DIRECTORY"))
|
||||
{
|
||||
this->SetHomeOutputDirectory(cachePath.c_str());
|
||||
this->SetStartOutputDirectory(cachePath.c_str());
|
||||
|
@ -565,7 +568,8 @@ void cmake::SetDirectoriesFromFile(const char* arg)
|
|||
this->SetStartOutputDirectory(cwd.c_str());
|
||||
}
|
||||
|
||||
// at the end of this CMAKE_ROOT and CMAKE_COMMAND should be added to the cache
|
||||
// at the end of this CMAKE_ROOT and CMAKE_COMMAND should be added to the
|
||||
// cache
|
||||
int cmake::AddCMakePaths(const char *arg0)
|
||||
{
|
||||
// Find our own executable.
|
||||
|
@ -734,9 +738,12 @@ void CMakeCommandUsage(const char* program)
|
|||
<< "Usage: " << program << " -E [command] [arguments ...]\n"
|
||||
<< "Available commands: \n"
|
||||
<< " chdir dir cmd [args]... - run command in a given directory\n"
|
||||
<< " copy file destination - copy file to destination (either file or directory)\n"
|
||||
<< " copy_if_different in-file out-file - copy file if input has changed\n"
|
||||
<< " copy_directory source destination - copy directory 'source' content to directory 'destination'\n"
|
||||
<< " copy file destination - copy file to destination (either file or "
|
||||
"directory)\n"
|
||||
<< " copy_if_different in-file out-file - copy file if input has "
|
||||
"changed\n"
|
||||
<< " copy_directory source destination - copy directory 'source' "
|
||||
"content to directory 'destination'\n"
|
||||
<< " compare_files file1 file2 - check if file1 is same as file2\n"
|
||||
<< " echo [string]... - displays arguments as text\n"
|
||||
<< " remove file1 file2 ... - remove the file(s)\n"
|
||||
|
@ -774,7 +781,8 @@ int cmake::CMakeCommand(std::vector<std::string>& args)
|
|||
// Copy file if different.
|
||||
if (args[1] == "copy_if_different" && args.size() == 4)
|
||||
{
|
||||
if(!cmSystemTools::CopyFileIfDifferent(args[2].c_str(), args[3].c_str()))
|
||||
if(!cmSystemTools::CopyFileIfDifferent(args[2].c_str(),
|
||||
args[3].c_str()))
|
||||
{
|
||||
std::cerr << "Error copying file (if different) from \""
|
||||
<< args[2].c_str() << "\" to \"" << args[3].c_str()
|
||||
|
@ -1011,7 +1019,8 @@ int cmake::CMakeCommand(std::vector<std::string>& args)
|
|||
}
|
||||
else if ( flags.find_first_of('c') != flags.npos )
|
||||
{
|
||||
if ( !cmSystemTools::CreateTar(outFile.c_str(), files, gzip, verbose) )
|
||||
if ( !cmSystemTools::CreateTar(
|
||||
outFile.c_str(), files, gzip, verbose) )
|
||||
{
|
||||
cmSystemTools::Error("Problem creating tar: ", outFile.c_str());
|
||||
return 1;
|
||||
|
@ -1019,7 +1028,8 @@ int cmake::CMakeCommand(std::vector<std::string>& args)
|
|||
}
|
||||
else if ( flags.find_first_of('x') != flags.npos )
|
||||
{
|
||||
if ( !cmSystemTools::ExtractTar(outFile.c_str(), files, gzip, verbose) )
|
||||
if ( !cmSystemTools::ExtractTar(
|
||||
outFile.c_str(), files, gzip, verbose) )
|
||||
{
|
||||
cmSystemTools::Error("Problem extracting tar: ", outFile.c_str());
|
||||
return 1;
|
||||
|
@ -1177,7 +1187,8 @@ int cmake::DoPreConfigureChecks()
|
|||
err << "The source directory \"" << this->GetHomeDirectory()
|
||||
<< "\" does not exist.\n";
|
||||
}
|
||||
err << "Specify --help for usage, or press the help button on the CMake GUI.";
|
||||
err << "Specify --help for usage, or press the help button on the CMake "
|
||||
"GUI.";
|
||||
cmSystemTools::Error(err.str().c_str());
|
||||
return -2;
|
||||
}
|
||||
|
@ -1228,7 +1239,8 @@ int cmake::Configure()
|
|||
{
|
||||
m_CacheManager->AddCacheEntry("CMAKE_HOME_DIRECTORY",
|
||||
this->GetHomeDirectory(),
|
||||
"Start directory with the top level CMakeLists.txt file for this project",
|
||||
"Start directory with the top level CMakeLists.txt file for this "
|
||||
"project",
|
||||
cmCacheManager::INTERNAL);
|
||||
}
|
||||
|
||||
|
@ -1240,7 +1252,8 @@ int cmake::Configure()
|
|||
cmMakefile::GetMinorVersion());
|
||||
this->m_CacheManager->AddCacheEntry
|
||||
("CMAKE_BACKWARDS_COMPATIBILITY",ver,
|
||||
"For backwards compatibility, what version of CMake commands and syntax should this version of CMake allow.",
|
||||
"For backwards compatibility, what version of CMake commands and "
|
||||
"syntax should this version of CMake allow.",
|
||||
cmCacheManager::STRING);
|
||||
}
|
||||
|
||||
|
@ -1257,7 +1270,8 @@ int cmake::Configure()
|
|||
// set the global flag for unix style paths on cmSystemTools as
|
||||
// soon as the generator is set. This allows gmake to be used
|
||||
// on windows.
|
||||
cmSystemTools::SetForceUnixPaths(m_GlobalGenerator->GetForceUnixPaths());
|
||||
cmSystemTools::SetForceUnixPaths(
|
||||
m_GlobalGenerator->GetForceUnixPaths());
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -1265,7 +1279,8 @@ int cmake::Configure()
|
|||
this->SetGlobalGenerator(new cmGlobalBorlandMakefileGenerator);
|
||||
#elif defined(_WIN32) && !defined(__CYGWIN__) && !defined(CMAKE_BOOT_MINGW)
|
||||
std::string installedCompiler;
|
||||
std::string mp = "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\8.0\\Setup;Dbghelp_path]";
|
||||
std::string mp = "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft"
|
||||
"\\VisualStudio\\8.0\\Setup;Dbghelp_path]";
|
||||
cmSystemTools::ExpandRegistryValues(mp);
|
||||
if (!(mp == "/registry"))
|
||||
{
|
||||
|
@ -1273,7 +1288,8 @@ int cmake::Configure()
|
|||
}
|
||||
else
|
||||
{
|
||||
mp = "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\7.1;InstallDir]";
|
||||
mp = "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft"
|
||||
"\\VisualStudio\\7.1;InstallDir]";
|
||||
cmSystemTools::ExpandRegistryValues(mp);
|
||||
if (!(mp == "/registry"))
|
||||
{
|
||||
|
@ -1281,7 +1297,8 @@ int cmake::Configure()
|
|||
}
|
||||
else
|
||||
{
|
||||
mp = "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\7.0;InstallDir]";
|
||||
mp = "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft"
|
||||
"\\VisualStudio\\7.0;InstallDir]";
|
||||
cmSystemTools::ExpandRegistryValues(mp);
|
||||
if (!(mp == "/registry"))
|
||||
{
|
||||
|
@ -1293,7 +1310,8 @@ int cmake::Configure()
|
|||
}
|
||||
}
|
||||
}
|
||||
cmGlobalGenerator* gen = this->CreateGlobalGenerator(installedCompiler.c_str());
|
||||
cmGlobalGenerator* gen
|
||||
= this->CreateGlobalGenerator(installedCompiler.c_str());
|
||||
if(!gen)
|
||||
{
|
||||
gen = new cmGlobalNMakeMakefileGenerator;
|
||||
|
@ -1328,7 +1346,8 @@ int cmake::Configure()
|
|||
}
|
||||
if(!m_CacheManager->GetCacheValue("CMAKE_GENERATOR"))
|
||||
{
|
||||
m_CacheManager->AddCacheEntry("CMAKE_GENERATOR", m_GlobalGenerator->GetName(),
|
||||
m_CacheManager->AddCacheEntry("CMAKE_GENERATOR",
|
||||
m_GlobalGenerator->GetName(),
|
||||
"Name of generator.",
|
||||
cmCacheManager::INTERNAL);
|
||||
}
|
||||
|
@ -1384,7 +1403,8 @@ int cmake::Configure()
|
|||
|
||||
if(cmSystemTools::GetFatalErrorOccured() &&
|
||||
(!this->m_CacheManager->GetCacheValue("CMAKE_MAKE_PROGRAM") ||
|
||||
cmSystemTools::IsOff(this->m_CacheManager->GetCacheValue("CMAKE_MAKE_PROGRAM"))))
|
||||
cmSystemTools::IsOff(
|
||||
this->m_CacheManager->GetCacheValue("CMAKE_MAKE_PROGRAM"))))
|
||||
{
|
||||
// We must have a bad generator selection. Wipe the cache entry so the
|
||||
// user can select another.
|
||||
|
@ -1409,9 +1429,12 @@ int cmake::Configure()
|
|||
|
||||
bool cmake::CacheVersionMatches()
|
||||
{
|
||||
const char* majv = m_CacheManager->GetCacheValue("CMAKE_CACHE_MAJOR_VERSION");
|
||||
const char* minv = m_CacheManager->GetCacheValue("CMAKE_CACHE_MINOR_VERSION");
|
||||
const char* relv = m_CacheManager->GetCacheValue("CMAKE_CACHE_RELEASE_VERSION");
|
||||
const char* majv
|
||||
= m_CacheManager->GetCacheValue("CMAKE_CACHE_MAJOR_VERSION");
|
||||
const char* minv
|
||||
= m_CacheManager->GetCacheValue("CMAKE_CACHE_MINOR_VERSION");
|
||||
const char* relv
|
||||
= m_CacheManager->GetCacheValue("CMAKE_CACHE_RELEASE_VERSION");
|
||||
bool cacheSameCMake = false;
|
||||
if(majv &&
|
||||
atoi(majv) == static_cast<int>(cmMakefile::GetMajorVersion())
|
||||
|
@ -1666,14 +1689,19 @@ int cmake::LoadCache()
|
|||
cacheFile += "/CMakeCache.txt";
|
||||
if(cmSystemTools::FileExists(cacheFile.c_str()))
|
||||
{
|
||||
cmSystemTools::Error("There is a CMakeCache.txt file for the current binary tree but cmake does not have permission to read it. Please check the permissions of the directory you are trying to run CMake on.");
|
||||
cmSystemTools::Error(
|
||||
"There is a CMakeCache.txt file for the current binary tree but "
|
||||
"cmake does not have permission to read it. Please check the "
|
||||
"permissions of the directory you are trying to run CMake on.");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
if (m_CMakeCommand.size() < 2)
|
||||
{
|
||||
cmSystemTools::Error("cmake command was not specified prior to loading the cache in cmake.cxx");
|
||||
cmSystemTools::Error(
|
||||
"cmake command was not specified prior to loading the cache in "
|
||||
"cmake.cxx");
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
@ -1691,7 +1719,8 @@ int cmake::LoadCache()
|
|||
cmMakefile::GetMinorVersion());
|
||||
this->m_CacheManager->AddCacheEntry
|
||||
("CMAKE_BACKWARDS_COMPATIBILITY",ver,
|
||||
"For backwards compatibility, what version of CMake commands and syntax should this version of CMake allow.",
|
||||
"For backwards compatibility, what version of CMake commands and "
|
||||
"syntax should this version of CMake allow.",
|
||||
cmCacheManager::STRING);
|
||||
}
|
||||
|
||||
|
@ -1713,7 +1742,8 @@ void cmake::UpdateProgress(const char *msg, float prog)
|
|||
}
|
||||
}
|
||||
|
||||
void cmake::GetCommandDocumentation(std::vector<cmDocumentationEntry>& v) const
|
||||
void cmake::GetCommandDocumentation(
|
||||
std::vector<cmDocumentationEntry>& v) const
|
||||
{
|
||||
for(RegisteredCommandsMap::const_iterator j = m_Commands.begin();
|
||||
j != m_Commands.end(); ++j)
|
||||
|
@ -1771,7 +1801,8 @@ void cmake::UpdateConversionPathTable()
|
|||
std::ifstream table( tablepath );
|
||||
if(!table)
|
||||
{
|
||||
cmSystemTools::Error("CMAKE_PATH_TRANSLATION_FILE set to ", tablepath, ". CMake can not open file.");
|
||||
cmSystemTools::Error("CMAKE_PATH_TRANSLATION_FILE set to ", tablepath,
|
||||
". CMake can not open file.");
|
||||
cmSystemTools::ReportLastSystemError("CMake can not open file.");
|
||||
}
|
||||
else
|
||||
|
@ -1917,7 +1948,8 @@ const char* cmake::GetCTestCommand()
|
|||
return m_CTestCommand.c_str();
|
||||
}
|
||||
|
||||
cmMakefile* mf = this->GetGlobalGenerator()->GetLocalGenerator(0)->GetMakefile();
|
||||
cmMakefile* mf
|
||||
= this->GetGlobalGenerator()->GetLocalGenerator(0)->GetMakefile();
|
||||
#ifdef CMAKE_BUILD_WITH_CMAKE
|
||||
m_CTestCommand = mf->GetRequiredDefinition("CMAKE_COMMAND");
|
||||
m_CTestCommand = removeQuotes(m_CTestCommand);
|
||||
|
@ -1962,7 +1994,8 @@ const char* cmake::GetCPackCommand()
|
|||
return m_CPackCommand.c_str();
|
||||
}
|
||||
|
||||
cmMakefile* mf = this->GetGlobalGenerator()->GetLocalGenerator(0)->GetMakefile();
|
||||
cmMakefile* mf
|
||||
= this->GetGlobalGenerator()->GetLocalGenerator(0)->GetMakefile();
|
||||
|
||||
#ifdef CMAKE_BUILD_WITH_CMAKE
|
||||
m_CPackCommand = mf->GetRequiredDefinition("CMAKE_COMMAND");
|
||||
|
@ -2031,10 +2064,12 @@ void cmake::GenerateGraphViz(const char* fileName)
|
|||
{
|
||||
if ( !mf->ReadListFile(0, infile.c_str()) )
|
||||
{
|
||||
cmSystemTools::Error("Problem opening GraphViz options file: ", infile.c_str());
|
||||
cmSystemTools::Error("Problem opening GraphViz options file: ",
|
||||
infile.c_str());
|
||||
return;
|
||||
}
|
||||
std::cout << "Read GraphViz options file: " << infile.c_str() << std::endl;
|
||||
std::cout << "Read GraphViz options file: " << infile.c_str()
|
||||
<< std::endl;
|
||||
}
|
||||
|
||||
#define __set_if_not_set(var, value, cmakeDefinition) \
|
||||
|
@ -2045,7 +2080,8 @@ void cmake::GenerateGraphViz(const char* fileName)
|
|||
}
|
||||
__set_if_not_set(graphType, "digraph", "GRAPHVIZ_GRAPH_TYPE");
|
||||
__set_if_not_set(graphName, "GG", "GRAPHVIZ_GRAPH_NAME");
|
||||
__set_if_not_set(graphHeader, "node [\n fontsize = \"12\"\n];", "GRAPHVIZ_GRAPH_HEADER");
|
||||
__set_if_not_set(graphHeader, "node [\n fontsize = \"12\"\n];",
|
||||
"GRAPHVIZ_GRAPH_HEADER");
|
||||
__set_if_not_set(graphNodePrefix, "node", "GRAPHVIZ_NODE_PREFIX");
|
||||
const char* ignoreTargets = mf->GetDefinition("GRAPHVIZ_IGNORE_TARGETS");
|
||||
std::set<cmStdString> ignoreTargetsSet;
|
||||
|
@ -2054,7 +2090,9 @@ void cmake::GenerateGraphViz(const char* fileName)
|
|||
std::vector<std::string> ignoreTargetsVector;
|
||||
cmSystemTools::ExpandListArgument(ignoreTargets,ignoreTargetsVector);
|
||||
std::vector<std::string>::iterator itvIt;
|
||||
for ( itvIt = ignoreTargetsVector.begin(); itvIt != ignoreTargetsVector.end(); ++ itvIt )
|
||||
for ( itvIt = ignoreTargetsVector.begin();
|
||||
itvIt != ignoreTargetsVector.end();
|
||||
++ itvIt )
|
||||
{
|
||||
ignoreTargetsSet.insert(itvIt->c_str());
|
||||
}
|
||||
|
@ -2093,7 +2131,8 @@ void cmake::GenerateGraphViz(const char* fileName)
|
|||
sprintf(tgtName, "%s%d", graphNodePrefix, cnt++);
|
||||
targetNamesNodes[realTargetName] = tgtName;
|
||||
targetPtrs[realTargetName] = &tit->second;
|
||||
//str << " \"" << tgtName << "\" [ label=\"" << tit->first.c_str() << "\" shape=\"box\"];" << std::endl;
|
||||
//str << " \"" << tgtName << "\" [ label=\"" << tit->first.c_str()
|
||||
//<< "\" shape=\"box\"];" << std::endl;
|
||||
}
|
||||
}
|
||||
// Ok, now find all the stuff we link to that is not in cmake
|
||||
|
@ -2103,7 +2142,8 @@ void cmake::GenerateGraphViz(const char* fileName)
|
|||
cmTargets::iterator tit;
|
||||
for ( tit = targets->begin(); tit != targets->end(); ++ tit )
|
||||
{
|
||||
const cmTarget::LinkLibraries* ll = &(tit->second.GetOriginalLinkLibraries());
|
||||
const cmTarget::LinkLibraries* ll
|
||||
= &(tit->second.GetOriginalLinkLibraries());
|
||||
cmTarget::LinkLibraries::const_iterator llit;
|
||||
const char* realTargetName = tit->first.c_str();
|
||||
if ( ignoreTargetsSet.find(realTargetName) != ignoreTargetsSet.end() )
|
||||
|
@ -2118,7 +2158,8 @@ void cmake::GenerateGraphViz(const char* fileName)
|
|||
for ( llit = ll->begin(); llit != ll->end(); ++ llit )
|
||||
{
|
||||
const char* libName = llit->first.c_str();
|
||||
std::map<cmStdString, cmStdString>::iterator tarIt = targetNamesNodes.find(libName);
|
||||
std::map<cmStdString, cmStdString>::iterator tarIt
|
||||
= targetNamesNodes.find(libName);
|
||||
if ( ignoreTargetsSet.find(libName) != ignoreTargetsSet.end() )
|
||||
{
|
||||
// Skip ignored targets
|
||||
|
@ -2129,11 +2170,13 @@ void cmake::GenerateGraphViz(const char* fileName)
|
|||
sprintf(tgtName, "%s%d", graphNodePrefix, cnt++);
|
||||
targetDeps[libName] = 2;
|
||||
targetNamesNodes[libName] = tgtName;
|
||||
//str << " \"" << tgtName << "\" [ label=\"" << libName << "\" shape=\"ellipse\"];" << std::endl;
|
||||
//str << " \"" << tgtName << "\" [ label=\"" << libName
|
||||
//<< "\" shape=\"ellipse\"];" << std::endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
std::map<cmStdString, int>::iterator depIt = targetDeps.find(libName);
|
||||
std::map<cmStdString, int>::iterator depIt
|
||||
= targetDeps.find(libName);
|
||||
if ( depIt == targetDeps.end() )
|
||||
{
|
||||
targetDeps[libName] = 1;
|
||||
|
@ -2148,22 +2191,27 @@ void cmake::GenerateGraphViz(const char* fileName)
|
|||
for ( depIt = targetDeps.begin(); depIt != targetDeps.end(); ++ depIt )
|
||||
{
|
||||
const char* newTargetName = depIt->first.c_str();
|
||||
std::map<cmStdString, cmStdString>::iterator tarIt = targetNamesNodes.find(newTargetName);
|
||||
std::map<cmStdString, cmStdString>::iterator tarIt
|
||||
= targetNamesNodes.find(newTargetName);
|
||||
if ( tarIt == targetNamesNodes.end() )
|
||||
{
|
||||
// We should not be here.
|
||||
std::cout << __LINE__ << " Cannot find library: " << newTargetName << " even though it was added in the previous pass" << std::endl;
|
||||
std::cout << __LINE__ << " Cannot find library: " << newTargetName
|
||||
<< " even though it was added in the previous pass" << std::endl;
|
||||
abort();
|
||||
}
|
||||
|
||||
str << " \"" << tarIt->second.c_str() << "\" [ label=\"" << newTargetName << "\" shape=\"";
|
||||
str << " \"" << tarIt->second.c_str() << "\" [ label=\""
|
||||
<< newTargetName << "\" shape=\"";
|
||||
if ( depIt->second == 1 )
|
||||
{
|
||||
std::map<cmStdString, cmTarget*>::iterator tarTypeIt= targetPtrs.find(newTargetName);
|
||||
std::map<cmStdString, cmTarget*>::iterator tarTypeIt= targetPtrs.find(
|
||||
newTargetName);
|
||||
if ( tarTypeIt == targetPtrs.end() )
|
||||
{
|
||||
// We should not be here.
|
||||
std::cout << __LINE__ << " Cannot find library: " << newTargetName << " even though it was added in the previous pass" << std::endl;
|
||||
std::cout << __LINE__ << " Cannot find library: " << newTargetName
|
||||
<< " even though it was added in the previous pass" << std::endl;
|
||||
abort();
|
||||
}
|
||||
cmTarget* tg = tarTypeIt->second;
|
||||
|
@ -2199,31 +2247,38 @@ void cmake::GenerateGraphViz(const char* fileName)
|
|||
cmTargets::iterator tit;
|
||||
for ( tit = targets->begin(); tit != targets->end(); ++ tit )
|
||||
{
|
||||
std::map<cmStdString, int>::iterator dependIt = targetDeps.find(tit->first.c_str());
|
||||
std::map<cmStdString, int>::iterator dependIt
|
||||
= targetDeps.find(tit->first.c_str());
|
||||
if ( dependIt == targetDeps.end() )
|
||||
{
|
||||
continue;
|
||||
}
|
||||
std::map<cmStdString, cmStdString>::iterator cmakeTarIt = targetNamesNodes.find(tit->first.c_str());
|
||||
const cmTarget::LinkLibraries* ll = &(tit->second.GetOriginalLinkLibraries());
|
||||
std::map<cmStdString, cmStdString>::iterator cmakeTarIt
|
||||
= targetNamesNodes.find(tit->first.c_str());
|
||||
const cmTarget::LinkLibraries* ll
|
||||
= &(tit->second.GetOriginalLinkLibraries());
|
||||
cmTarget::LinkLibraries::const_iterator llit;
|
||||
for ( llit = ll->begin(); llit != ll->end(); ++ llit )
|
||||
{
|
||||
const char* libName = llit->first.c_str();
|
||||
std::map<cmStdString, cmStdString>::iterator tarIt = targetNamesNodes.find(libName);
|
||||
std::map<cmStdString, cmStdString>::iterator tarIt
|
||||
= targetNamesNodes.find(libName);
|
||||
if ( tarIt == targetNamesNodes.end() )
|
||||
{
|
||||
// We should not be here.
|
||||
std::cout << __LINE__ << " Cannot find library: " << libName << " even though it was added in the previous pass" << std::endl;
|
||||
std::cout << __LINE__ << " Cannot find library: " << libName
|
||||
<< " even though it was added in the previous pass" << std::endl;
|
||||
abort();
|
||||
}
|
||||
str << " \"" << cmakeTarIt->second.c_str() << "\" -> \"" << tarIt->second.c_str() << "\"" << std::endl;
|
||||
str << " \"" << cmakeTarIt->second.c_str() << "\" -> \""
|
||||
<< tarIt->second.c_str() << "\"" << std::endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: Use dotted or something for external libraries
|
||||
//str << " \"node0\":f4 -> \"node12\"[color=\"#0000ff\" style=dotted]" << std::endl;
|
||||
//str << " \"node0\":f4 -> \"node12\"[color=\"#0000ff\" style=dotted]"
|
||||
//<< std::endl;
|
||||
//
|
||||
str << "}" << std::endl;
|
||||
}
|
||||
|
|
|
@ -24,7 +24,8 @@ cmakewizard::cmakewizard()
|
|||
}
|
||||
|
||||
|
||||
void cmakewizard::AskUser(const char* key, cmCacheManager::CacheIterator& iter)
|
||||
void cmakewizard::AskUser(const char* key,
|
||||
cmCacheManager::CacheIterator& iter)
|
||||
{
|
||||
printf("Variable Name: %s\n", key);
|
||||
const char* helpstring = iter.GetProperty("HELPSTRING");
|
||||
|
@ -105,7 +106,8 @@ int cmakewizard::RunWizard(std::vector<std::string> const& args)
|
|||
{
|
||||
asked = false;
|
||||
// run cmake
|
||||
this->ShowMessage("Please wait while cmake processes CMakeLists.txt files....\n");
|
||||
this->ShowMessage(
|
||||
"Please wait while cmake processes CMakeLists.txt files....\n");
|
||||
|
||||
make.Configure();
|
||||
this->ShowMessage("\n");
|
||||
|
|
Loading…
Reference in New Issue