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

Port static calls from cmLocalGenerator to cmOutputConverter.

This commit is contained in:
Stephen Kelly 2015-05-16 00:55:21 +02:00
parent 242dcc2c22
commit 59e21ffa13
7 changed files with 40 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Source/cmCPackPropertiesGenerator.cxx
View File

@ -1,6 +1,6 @@
#include "cmCPackPropertiesGenerator.h" #include "cmCPackPropertiesGenerator.h"
#include "cmLocalGenerator.h" #include "cmOutputConverter.h"
cmCPackPropertiesGenerator::cmCPackPropertiesGenerator( cmCPackPropertiesGenerator::cmCPackPropertiesGenerator(
cmMakefile* mf, cmMakefile* mf,
@ -29,15 +29,15 @@ void cmCPackPropertiesGenerator::GenerateScriptForConfig(std::ostream& os,
cmInstalledFile::Property const& property = i->second; cmInstalledFile::Property const& property = i->second;
os << indent << "set_property(INSTALL " << os << indent << "set_property(INSTALL " <<
cmLocalGenerator::EscapeForCMake(expandedFileName) << " PROPERTY " << cmOutputConverter::EscapeForCMake(expandedFileName) << " PROPERTY " <<
cmLocalGenerator::EscapeForCMake(name); cmOutputConverter::EscapeForCMake(name);
for(cmInstalledFile::ExpressionVectorType::const_iterator for(cmInstalledFile::ExpressionVectorType::const_iterator
j = property.ValueExpressions.begin(); j = property.ValueExpressions.begin();
j != property.ValueExpressions.end(); ++j) j != property.ValueExpressions.end(); ++j)
{ {
std::string value = (*j)->Evaluate(this->Makefile, config); std::string value = (*j)->Evaluate(this->Makefile, config);
os << " " << cmLocalGenerator::EscapeForCMake(value); os << " " << cmOutputConverter::EscapeForCMake(value);
} }
os << ")\n"; os << ")\n";

6
Source/cmCoreTryCompile.cxx
View File

@ -11,7 +11,7 @@
============================================================================*/ ============================================================================*/
#include "cmCoreTryCompile.h" #include "cmCoreTryCompile.h"
#include "cmake.h" #include "cmake.h"
#include "cmLocalGenerator.h" #include "cmOutputConverter.h"
#include "cmGlobalGenerator.h" #include "cmGlobalGenerator.h"
#include "cmAlgorithms.h" #include "cmAlgorithms.h"
#include "cmExportTryCompileFileGenerator.h" #include "cmExportTryCompileFileGenerator.h"
@ -322,7 +322,7 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv)
std::string langFlags = "CMAKE_" + *li + "_FLAGS"; std::string langFlags = "CMAKE_" + *li + "_FLAGS";
const char* flags = this->Makefile->GetDefinition(langFlags); const char* flags = this->Makefile->GetDefinition(langFlags);
fprintf(fout, "set(CMAKE_%s_FLAGS %s)\n", li->c_str(), fprintf(fout, "set(CMAKE_%s_FLAGS %s)\n", li->c_str(),
cmLocalGenerator::EscapeForCMake(flags?flags:"").c_str()); cmOutputConverter::EscapeForCMake(flags?flags:"").c_str());
fprintf(fout, "set(CMAKE_%s_FLAGS \"${CMAKE_%s_FLAGS}" fprintf(fout, "set(CMAKE_%s_FLAGS \"${CMAKE_%s_FLAGS}"
" ${COMPILE_DEFINITIONS}\")\n", li->c_str(), li->c_str()); " ${COMPILE_DEFINITIONS}\")\n", li->c_str(), li->c_str());
} }
@ -355,7 +355,7 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv)
const char* exeLinkFlags = const char* exeLinkFlags =
this->Makefile->GetDefinition("CMAKE_EXE_LINKER_FLAGS"); this->Makefile->GetDefinition("CMAKE_EXE_LINKER_FLAGS");
fprintf(fout, "set(CMAKE_EXE_LINKER_FLAGS %s)\n", fprintf(fout, "set(CMAKE_EXE_LINKER_FLAGS %s)\n",
cmLocalGenerator::EscapeForCMake( cmOutputConverter::EscapeForCMake(
exeLinkFlags ? exeLinkFlags : "").c_str()); exeLinkFlags ? exeLinkFlags : "").c_str());
} break; } break;
} }

2
Source/cmIfCommand.cxx
View File

@ -27,7 +27,7 @@ static std::string cmIfCommandError(
i != args.end(); ++i) i != args.end(); ++i)
{ {
err += " "; err += " ";
err += cmLocalGenerator::EscapeForCMake(i->GetValue()); err += cmOutputConverter::EscapeForCMake(i->GetValue());
} }
err += "\n"; err += "\n";
return err; return err;

6
Source/cmLocalUnixMakefileGenerator3.cxx
View File

@ -1254,7 +1254,7 @@ cmLocalUnixMakefileGenerator3
f != files.end(); ++f) f != files.end(); ++f)
{ {
std::string fc = this->Convert(*f,START_OUTPUT,UNCHANGED); std::string fc = this->Convert(*f,START_OUTPUT,UNCHANGED);
fout << " " << cmLocalGenerator::EscapeForCMake(fc) << "\n"; fout << " " << cmOutputConverter::EscapeForCMake(fc) << "\n";
} }
fout << ")\n"; fout << ")\n";
} }
@ -2052,7 +2052,7 @@ void cmLocalUnixMakefileGenerator3
di != defines.end(); ++di) di != defines.end(); ++di)
{ {
cmakefileStream cmakefileStream
<< " " << cmLocalGenerator::EscapeForCMake(*di) << "\n"; << " " << cmOutputConverter::EscapeForCMake(*di) << "\n";
} }
cmakefileStream cmakefileStream
<< " )\n"; << " )\n";
@ -2106,7 +2106,7 @@ void cmLocalUnixMakefileGenerator3
tri != transformRules.end(); ++tri) tri != transformRules.end(); ++tri)
{ {
cmakefileStream << " " cmakefileStream << " "
<< cmLocalGenerator::EscapeForCMake(*tri) << "\n"; << cmOutputConverter::EscapeForCMake(*tri) << "\n";
} }
cmakefileStream cmakefileStream
<< " )\n"; << " )\n";

4
Source/cmMakefileTargetGenerator.cxx
View File

@ -1126,8 +1126,8 @@ void cmMakefileTargetGenerator::WriteTargetDependRules()
pi != this->MultipleOutputPairs.end(); ++pi) pi != this->MultipleOutputPairs.end(); ++pi)
{ {
*this->InfoFileStream *this->InfoFileStream
<< " " << cmLocalGenerator::EscapeForCMake(pi->first) << " " << cmOutputConverter::EscapeForCMake(pi->first)
<< " " << cmLocalGenerator::EscapeForCMake(pi->second) << " " << cmOutputConverter::EscapeForCMake(pi->second)
<< "\n"; << "\n";
} }
*this->InfoFileStream << " )\n\n"; *this->InfoFileStream << " )\n\n";

40
Source/cmQtAutoGenerators.cxx
View File

@ -550,9 +550,9 @@ void cmQtAutoGenerators::SetupAutoGenerateTarget(cmTarget const* target)
std::string autogenTargetName = getAutogenTargetName(target); std::string autogenTargetName = getAutogenTargetName(target);
makefile->AddDefinition("_moc_target_name", makefile->AddDefinition("_moc_target_name",
cmLocalGenerator::EscapeForCMake(autogenTargetName).c_str()); cmOutputConverter::EscapeForCMake(autogenTargetName).c_str());
makefile->AddDefinition("_origin_target_name", makefile->AddDefinition("_origin_target_name",
cmLocalGenerator::EscapeForCMake(target->GetName()).c_str()); cmOutputConverter::EscapeForCMake(target->GetName()).c_str());
std::string targetDir = getAutogenTargetDir(target); std::string targetDir = getAutogenTargetDir(target);
@ -582,7 +582,7 @@ void cmQtAutoGenerators::SetupAutoGenerateTarget(cmTarget const* target)
this->SetupSourceFiles(target); this->SetupSourceFiles(target);
} }
makefile->AddDefinition("_cpp_files", makefile->AddDefinition("_cpp_files",
cmLocalGenerator::EscapeForCMake(this->Sources).c_str()); cmOutputConverter::EscapeForCMake(this->Sources).c_str());
if (target->GetPropertyAsBool("AUTOMOC")) if (target->GetPropertyAsBool("AUTOMOC"))
{ {
this->SetupAutoMocTarget(target, autogenTargetName, this->SetupAutoMocTarget(target, autogenTargetName,
@ -764,11 +764,11 @@ void cmQtAutoGenerators::SetupAutoMocTarget(cmTarget const* target,
const char* tmp = target->GetProperty("AUTOMOC_MOC_OPTIONS"); const char* tmp = target->GetProperty("AUTOMOC_MOC_OPTIONS");
std::string _moc_options = (tmp!=0 ? tmp : ""); std::string _moc_options = (tmp!=0 ? tmp : "");
makefile->AddDefinition("_moc_options", makefile->AddDefinition("_moc_options",
cmLocalGenerator::EscapeForCMake(_moc_options).c_str()); cmOutputConverter::EscapeForCMake(_moc_options).c_str());
makefile->AddDefinition("_skip_moc", makefile->AddDefinition("_skip_moc",
cmLocalGenerator::EscapeForCMake(this->SkipMoc).c_str()); cmOutputConverter::EscapeForCMake(this->SkipMoc).c_str());
makefile->AddDefinition("_moc_headers", makefile->AddDefinition("_moc_headers",
cmLocalGenerator::EscapeForCMake(this->Headers).c_str()); cmOutputConverter::EscapeForCMake(this->Headers).c_str());
bool relaxedMode = makefile->IsOn("CMAKE_AUTOMOC_RELAXED_MODE"); bool relaxedMode = makefile->IsOn("CMAKE_AUTOMOC_RELAXED_MODE");
makefile->AddDefinition("_moc_relaxed_mode", relaxedMode ? "TRUE" : "FALSE"); makefile->AddDefinition("_moc_relaxed_mode", relaxedMode ? "TRUE" : "FALSE");
@ -780,9 +780,9 @@ void cmQtAutoGenerators::SetupAutoMocTarget(cmTarget const* target,
_moc_incs, _moc_compile_defs); _moc_incs, _moc_compile_defs);
makefile->AddDefinition("_moc_incs", makefile->AddDefinition("_moc_incs",
cmLocalGenerator::EscapeForCMake(_moc_incs).c_str()); cmOutputConverter::EscapeForCMake(_moc_incs).c_str());
makefile->AddDefinition("_moc_compile_defs", makefile->AddDefinition("_moc_compile_defs",
cmLocalGenerator::EscapeForCMake(_moc_compile_defs).c_str()); cmOutputConverter::EscapeForCMake(_moc_compile_defs).c_str());
for (std::vector<std::string>::const_iterator li = configs.begin(); for (std::vector<std::string>::const_iterator li = configs.begin();
li != configs.end(); ++li) li != configs.end(); ++li)
@ -795,7 +795,7 @@ void cmQtAutoGenerators::SetupAutoMocTarget(cmTarget const* target,
if (config_moc_incs != _moc_incs) if (config_moc_incs != _moc_incs)
{ {
configIncludes[*li] = configIncludes[*li] =
cmLocalGenerator::EscapeForCMake(config_moc_incs); cmOutputConverter::EscapeForCMake(config_moc_incs);
if(_moc_incs.empty()) if(_moc_incs.empty())
{ {
_moc_incs = config_moc_incs; _moc_incs = config_moc_incs;
@ -804,7 +804,7 @@ void cmQtAutoGenerators::SetupAutoMocTarget(cmTarget const* target,
if (config_moc_compile_defs != _moc_compile_defs) if (config_moc_compile_defs != _moc_compile_defs)
{ {
configDefines[*li] = configDefines[*li] =
cmLocalGenerator::EscapeForCMake(config_moc_compile_defs); cmOutputConverter::EscapeForCMake(config_moc_compile_defs);
if(_moc_compile_defs.empty()) if(_moc_compile_defs.empty())
{ {
_moc_compile_defs = config_moc_compile_defs; _moc_compile_defs = config_moc_compile_defs;
@ -906,7 +906,7 @@ void cmQtAutoGenerators::SetupAutoUicTarget(cmTarget const* target,
skipped.insert(skipVec.begin(), skipVec.end()); skipped.insert(skipVec.begin(), skipVec.end());
makefile->AddDefinition("_skip_uic", makefile->AddDefinition("_skip_uic",
cmLocalGenerator::EscapeForCMake(this->SkipUic).c_str()); cmOutputConverter::EscapeForCMake(this->SkipUic).c_str());
std::vector<cmSourceFile*> uiFilesWithOptions std::vector<cmSourceFile*> uiFilesWithOptions
= makefile->GetQtUiFilesWithOptions(); = makefile->GetQtUiFilesWithOptions();
@ -920,7 +920,7 @@ void cmQtAutoGenerators::SetupAutoUicTarget(cmTarget const* target,
if (!_uic_opts.empty()) if (!_uic_opts.empty())
{ {
_uic_opts = cmLocalGenerator::EscapeForCMake(_uic_opts); _uic_opts = cmOutputConverter::EscapeForCMake(_uic_opts);
makefile->AddDefinition("_uic_target_options", _uic_opts.c_str()); makefile->AddDefinition("_uic_target_options", _uic_opts.c_str());
} }
for (std::vector<std::string>::const_iterator li = configs.begin(); for (std::vector<std::string>::const_iterator li = configs.begin();
@ -931,7 +931,7 @@ void cmQtAutoGenerators::SetupAutoUicTarget(cmTarget const* target,
if (config_uic_opts != _uic_opts) if (config_uic_opts != _uic_opts)
{ {
configUicOptions[*li] = configUicOptions[*li] =
cmLocalGenerator::EscapeForCMake(config_uic_opts); cmOutputConverter::EscapeForCMake(config_uic_opts);
if(_uic_opts.empty()) if(_uic_opts.empty())
{ {
_uic_opts = config_uic_opts; _uic_opts = config_uic_opts;
@ -966,9 +966,9 @@ void cmQtAutoGenerators::SetupAutoUicTarget(cmTarget const* target,
} }
makefile->AddDefinition("_qt_uic_options_files", makefile->AddDefinition("_qt_uic_options_files",
cmLocalGenerator::EscapeForCMake(uiFileFiles).c_str()); cmOutputConverter::EscapeForCMake(uiFileFiles).c_str());
makefile->AddDefinition("_qt_uic_options_options", makefile->AddDefinition("_qt_uic_options_options",
cmLocalGenerator::EscapeForCMake(uiFileOptions).c_str()); cmOutputConverter::EscapeForCMake(uiFileOptions).c_str());
std::string targetName = target->GetName(); std::string targetName = target->GetName();
if (strcmp(qtVersion, "5") == 0) if (strcmp(qtVersion, "5") == 0)
@ -1141,15 +1141,15 @@ void cmQtAutoGenerators::SetupAutoRccTarget(cmTarget const* target)
} }
} }
makefile->AddDefinition("_qt_rcc_inputs_" + target->GetName(), makefile->AddDefinition("_qt_rcc_inputs_" + target->GetName(),
cmLocalGenerator::EscapeForCMake(qrcInputs).c_str()); cmOutputConverter::EscapeForCMake(qrcInputs).c_str());
makefile->AddDefinition("_rcc_files", makefile->AddDefinition("_rcc_files",
cmLocalGenerator::EscapeForCMake(_rcc_files).c_str()); cmOutputConverter::EscapeForCMake(_rcc_files).c_str());
makefile->AddDefinition("_qt_rcc_options_files", makefile->AddDefinition("_qt_rcc_options_files",
cmLocalGenerator::EscapeForCMake(rccFileFiles).c_str()); cmOutputConverter::EscapeForCMake(rccFileFiles).c_str());
makefile->AddDefinition("_qt_rcc_options_options", makefile->AddDefinition("_qt_rcc_options_options",
cmLocalGenerator::EscapeForCMake(rccFileOptions).c_str()); cmOutputConverter::EscapeForCMake(rccFileOptions).c_str());
makefile->AddDefinition("_qt_rcc_executable", makefile->AddDefinition("_qt_rcc_executable",
this->GetRccExecutable(target).c_str()); this->GetRccExecutable(target).c_str());
@ -1434,7 +1434,7 @@ cmQtAutoGenerators::WriteOldMocDefinitionsFile(
outfile.open(filename.c_str(), outfile.open(filename.c_str(),
std::ios::trunc); std::ios::trunc);
outfile << "set(AM_OLD_COMPILE_SETTINGS " outfile << "set(AM_OLD_COMPILE_SETTINGS "
<< cmLocalGenerator::EscapeForCMake( << cmOutputConverter::EscapeForCMake(
this->CurrentCompileSettingsStr) << ")\n"; this->CurrentCompileSettingsStr) << ")\n";
outfile.close(); outfile.close();

14
Source/cmTestGenerator.cxx
View File

@ -12,7 +12,7 @@
#include "cmTestGenerator.h" #include "cmTestGenerator.h"
#include "cmGeneratorExpression.h" #include "cmGeneratorExpression.h"
#include "cmLocalGenerator.h" #include "cmOutputConverter.h"
#include "cmMakefile.h" #include "cmMakefile.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include "cmTarget.h" #include "cmTarget.h"
@ -97,13 +97,13 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os,
cmSystemTools::ExpandListArgument(emulator, emulatorWithArgs); cmSystemTools::ExpandListArgument(emulator, emulatorWithArgs);
std::string emulatorExe(emulatorWithArgs[0]); std::string emulatorExe(emulatorWithArgs[0]);
cmSystemTools::ConvertToUnixSlashes(emulatorExe); cmSystemTools::ConvertToUnixSlashes(emulatorExe);
os << cmLocalGenerator::EscapeForCMake(emulatorExe) << " "; os << cmOutputConverter::EscapeForCMake(emulatorExe) << " ";
for(std::vector<std::string>::const_iterator ei = for(std::vector<std::string>::const_iterator ei =
emulatorWithArgs.begin()+1; emulatorWithArgs.begin()+1;
ei != emulatorWithArgs.end(); ei != emulatorWithArgs.end();
++ei) ++ei)
{ {
os << cmLocalGenerator::EscapeForCMake(*ei) << " "; os << cmOutputConverter::EscapeForCMake(*ei) << " ";
} }
} }
} }
@ -115,11 +115,11 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os,
} }
// Generate the command line with full escapes. // Generate the command line with full escapes.
os << cmLocalGenerator::EscapeForCMake(exe); os << cmOutputConverter::EscapeForCMake(exe);
for(std::vector<std::string>::const_iterator ci = command.begin()+1; for(std::vector<std::string>::const_iterator ci = command.begin()+1;
ci != command.end(); ++ci) ci != command.end(); ++ci)
{ {
os << " " << cmLocalGenerator::EscapeForCMake( os << " " << cmOutputConverter::EscapeForCMake(
ge.Parse(*ci)->Evaluate(mf, config)); ge.Parse(*ci)->Evaluate(mf, config));
} }
@ -136,7 +136,7 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os,
i != pm.end(); ++i) i != pm.end(); ++i)
{ {
os << " " << i->first os << " " << i->first
<< " " << cmLocalGenerator::EscapeForCMake( << " " << cmOutputConverter::EscapeForCMake(
ge.Parse(i->second.GetValue())->Evaluate(mf, config)); ge.Parse(i->second.GetValue())->Evaluate(mf, config));
} }
os << ")" << std::endl; os << ")" << std::endl;
@ -206,7 +206,7 @@ void cmTestGenerator::GenerateOldStyle(std::ostream& fout,
i != pm.end(); ++i) i != pm.end(); ++i)
{ {
fout << " " << i->first fout << " " << i->first
<< " " << cmLocalGenerator::EscapeForCMake(i->second.GetValue()); << " " << cmOutputConverter::EscapeForCMake(i->second.GetValue());
} }
fout << ")" << std::endl; fout << ")" << std::endl;
} }