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

ENH: big change in the path handling, one function CreateOutputPath is used to escape spaces and convert to the native path type

Browse Source
This commit is contained in:
Bill Hoffman 2002-02-22 13:38:33 -05:00
parent bfcf4b02bf
commit 8c3400dc6b
11 changed files with 274 additions and 276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
Source/cmBorlandMakefileGenerator.cxx
View File

@ -101,18 +101,18 @@ void cmBorlandMakefileGenerator::OutputMakeVariables(std::ostream& fout)
m_Makefile->ExpandVariablesInString(replaceVars); m_Makefile->ExpandVariablesInString(replaceVars);
std::string ccompiler = m_Makefile->GetDefinition("CMAKE_C_COMPILER"); std::string ccompiler = m_Makefile->GetDefinition("CMAKE_C_COMPILER");
cmSystemTools::ConvertToWindowsSlashes(ccompiler); fout << "CMAKE_C_COMPILER = "
fout << "CMAKE_C_COMPILER = " << cmSystemTools::EscapeSpaces(ccompiler.c_str()) << this->ConvertToOutputPath(ccompiler.c_str())
<< "\n"; << "\n";
std::string cxxcompiler = m_Makefile->GetDefinition("CMAKE_CXX_COMPILER"); std::string cxxcompiler = m_Makefile->GetDefinition("CMAKE_CXX_COMPILER");
cmSystemTools::ConvertToWindowsSlashes(cxxcompiler); fout << "CMAKE_CXX_COMPILER = "
fout << "CMAKE_CXX_COMPILER = " << cmSystemTools::EscapeSpaces(cxxcompiler.c_str()) << this->ConvertToOutputPath(cxxcompiler.c_str())
<< "\n"; << "\n";
std::string cmakecommand = m_Makefile->GetDefinition("CMAKE_COMMAND"); std::string cmakecommand = m_Makefile->GetDefinition("CMAKE_COMMAND");
cmSystemTools::ConvertToWindowsSlashes(cmakecommand); fout << "CMAKE_COMMAND = "
fout << "CMAKE_COMMAND = " << cmSystemTools::EscapeSpaces(cmakecommand.c_str()) << "\n"; << this->ConvertToOutputPath(cmakecommand.c_str()) << "\n";
fout << replaceVars.c_str(); fout << replaceVars.c_str();
fout << "CMAKE_CURRENT_SOURCE = " fout << "CMAKE_CURRENT_SOURCE = "
@ -130,17 +130,15 @@ void cmBorlandMakefileGenerator::OutputMakeVariables(std::ostream& fout)
fout << "INCLUDE_FLAGS = "; fout << "INCLUDE_FLAGS = ";
std::vector<std::string>& includes = m_Makefile->GetIncludeDirectories(); std::vector<std::string>& includes = m_Makefile->GetIncludeDirectories();
std::vector<std::string>::iterator i; std::vector<std::string>::iterator i;
fout << "-I" << cmSystemTools::EscapeSpaces(m_Makefile->GetStartDirectory()) << " "; fout << "-I" <<
this->ConvertToOutputPath(m_Makefile->GetStartDirectory()) << " ";
for(i = includes.begin(); i != includes.end(); ++i) for(i = includes.begin(); i != includes.end(); ++i)
{ {
std::string include = *i; std::string include = *i;
// Don't output a -I for the standard include path "/usr/include". // Don't output a -I for the standard include path "/usr/include".
// This can cause problems with certain standard library // This can cause problems with certain standard library
// implementations because the wrong headers may be found first. // implementations because the wrong headers may be found first.
if(include != "/usr/include") fout << "-I" << this->ConvertToOutputPath(i->c_str()).c_str() << " ";
{
fout << "-I" << cmSystemTools::EscapeSpaces(i->c_str()).c_str() << " ";
}
} }
fout << m_Makefile->GetDefineFlags(); fout << m_Makefile->GetDefineFlags();
fout << "\n\n"; fout << "\n\n";
@ -168,7 +166,7 @@ OutputBuildObjectFromSource(std::ostream& fout,
std::string comment = "Build "; std::string comment = "Build ";
std::string objectFile = std::string(shortName) + std::string objectFile = std::string(shortName) +
this->GetOutputExtension(source.GetSourceExtension().c_str()); this->GetOutputExtension(source.GetSourceExtension().c_str());
cmSystemTools::ConvertToWindowsSlashes(objectFile); objectFile = this->ConvertToOutputPath(objectFile.c_str());
comment += objectFile + " From "; comment += objectFile + " From ";
comment += source.GetFullPath(); comment += source.GetFullPath();
std::string compileCommand; std::string compileCommand;
@ -185,7 +183,7 @@ OutputBuildObjectFromSource(std::ostream& fout,
compileCommand += objectFile; compileCommand += objectFile;
compileCommand += " $(INCLUDE_FLAGS) -c "; compileCommand += " $(INCLUDE_FLAGS) -c ";
compileCommand += compileCommand +=
cmSystemTools::EscapeSpaces(source.GetFullPath().c_str()); this->ConvertToOutputPath(source.GetFullPath().c_str());
} }
else if (ext == "rc") else if (ext == "rc")
{ {
@ -193,7 +191,7 @@ OutputBuildObjectFromSource(std::ostream& fout,
compileCommand += objectFile; compileCommand += objectFile;
compileCommand += "\" "; compileCommand += "\" ";
compileCommand += compileCommand +=
cmSystemTools::EscapeSpaces(source.GetFullPath().c_str()); this->ConvertToOutputPath(source.GetFullPath().c_str());
} }
else if (ext == "def") else if (ext == "def")
{ {
@ -213,12 +211,12 @@ OutputBuildObjectFromSource(std::ostream& fout,
compileCommand += objectFile; compileCommand += objectFile;
compileCommand += " $(INCLUDE_FLAGS) -c "; compileCommand += " $(INCLUDE_FLAGS) -c ";
compileCommand += compileCommand +=
cmSystemTools::EscapeSpaces(source.GetFullPath().c_str()); this->ConvertToOutputPath(source.GetFullPath().c_str());
} }
this->OutputMakeRule(fout, this->OutputMakeRule(fout,
comment.c_str(), comment.c_str(),
objectFile.c_str(), objectFile.c_str(),
cmSystemTools::EscapeSpaces( this->ConvertToOutputPath(
source.GetFullPath().c_str()).c_str(), source.GetFullPath().c_str()).c_str(),
compileCommand.c_str()); compileCommand.c_str());
} }
@ -230,10 +228,8 @@ void cmBorlandMakefileGenerator::OutputSharedLibraryRule(std::ostream& fout,
std::string target = m_LibraryOutputPath + name; std::string target = m_LibraryOutputPath + name;
std::string libpath = target + ".lib"; std::string libpath = target + ".lib";
target += ".dll"; target += ".dll";
cmSystemTools::ConvertToWindowsSlashes(libpath); target = this->ConvertToOutputPath(target.c_str());
cmSystemTools::ConvertToWindowsSlashes(target); libpath = this->ConvertToOutputPath(libpath.c_str());
target = cmSystemTools::EscapeSpaces(target.c_str());
libpath = cmSystemTools::EscapeSpaces(libpath.c_str());
std::string depend = "$("; std::string depend = "$(";
depend += this->CreateMakeVariable(name, "_SRC_OBJS"); depend += this->CreateMakeVariable(name, "_SRC_OBJS");
depend += ") $(" + this->CreateMakeVariable(name, "_DEPEND_LIBS") + ")"; depend += ") $(" + this->CreateMakeVariable(name, "_DEPEND_LIBS") + ")";
@ -290,8 +286,7 @@ void cmBorlandMakefileGenerator::OutputStaticLibraryRule(std::ostream& fout,
const cmTarget &t) const cmTarget &t)
{ {
std::string target = m_LibraryOutputPath + std::string(name) + ".lib"; std::string target = m_LibraryOutputPath + std::string(name) + ".lib";
cmSystemTools::ConvertToWindowsSlashes(target); target = this->ConvertToOutputPath(target.c_str());
target = cmSystemTools::EscapeSpaces(target.c_str());
std::string depend = "$("; std::string depend = "$(";
depend += this->CreateMakeVariable(name, "_SRC_OBJS") + ") "; depend += this->CreateMakeVariable(name, "_SRC_OBJS") + ") ";
std::string command = "tlib @&&|\n\t /p512 /a "; std::string command = "tlib @&&|\n\t /p512 /a ";
@ -326,8 +321,7 @@ void cmBorlandMakefileGenerator::OutputExecutableRule(std::ostream& fout,
const cmTarget &t) const cmTarget &t)
{ {
std::string target = m_ExecutableOutputPath + name + m_ExecutableExtension; std::string target = m_ExecutableOutputPath + name + m_ExecutableExtension;
cmSystemTools::ConvertToWindowsSlashes(target); target = this->ConvertToOutputPath(target.c_str());
target = cmSystemTools::EscapeSpaces(target.c_str());
std::string depend = "$("; std::string depend = "$(";
depend += this->CreateMakeVariable(name, "_SRC_OBJS") + ") $(" + depend += this->CreateMakeVariable(name, "_SRC_OBJS") + ") $(" +
this->CreateMakeVariable(name, "_DEPEND_LIBS") + ")"; this->CreateMakeVariable(name, "_DEPEND_LIBS") + ")";

46
Source/cmDSPWriter.cxx
View File

@ -48,8 +48,7 @@ void cmDSPWriter::OutputDSPFile()
for(i = includes.begin(); i != includes.end(); ++i) for(i = includes.begin(); i != includes.end(); ++i)
{ {
m_IncludeOptions += " /I "; m_IncludeOptions += " /I ";
std::string tmp = cmSystemTools::EscapeSpaces(i->c_str()); std::string tmp = cmSystemTools::ConvertToOutputPath(i->c_str());
cmSystemTools::ConvertToWindowsSlashesAndCleanUp(tmp);
// quote if not already quoted // quote if not already quoted
if (tmp[0] != '"') if (tmp[0] != '"')
@ -147,20 +146,23 @@ void cmDSPWriter::AddDSPBuildRule(cmSourceGroup& sourceGroup)
std::string makefileIn = m_Makefile->GetStartDirectory(); std::string makefileIn = m_Makefile->GetStartDirectory();
makefileIn += "/"; makefileIn += "/";
makefileIn += "CMakeLists.txt"; makefileIn += "CMakeLists.txt";
makefileIn = cmSystemTools::HandleNetworkPaths(makefileIn.c_str()); makefileIn = cmSystemTools::ConvertToOutputPath(makefileIn.c_str());
makefileIn = cmSystemTools::EscapeSpaces(makefileIn.c_str());
std::string dsprule = "${CMAKE_COMMAND}"; std::string dsprule = "${CMAKE_COMMAND}";
m_Makefile->ExpandVariablesInString(dsprule); m_Makefile->ExpandVariablesInString(dsprule);
dsprule = cmSystemTools::HandleNetworkPaths(dsprule.c_str()); dsprule = cmSystemTools::ConvertToOutputPath(dsprule.c_str());
std::string args = makefileIn; std::string args = makefileIn;
args += " -H\""; args += " -H\"";
args += cmSystemTools::HandleNetworkPaths(m_Makefile->GetHomeDirectory()); args +=
cmSystemTools::ConvertToOutputPath(m_Makefile->GetHomeDirectory());
args += "\" -S\""; args += "\" -S\"";
args += cmSystemTools::HandleNetworkPaths(m_Makefile->GetStartDirectory()); args +=
cmSystemTools::ConvertToOutputPath(m_Makefile->GetStartDirectory());
args += "\" -O\""; args += "\" -O\"";
args += cmSystemTools::HandleNetworkPaths(m_Makefile->GetStartOutputDirectory()); args +=
cmSystemTools::ConvertToOutputPath(m_Makefile->GetStartOutputDirectory());
args += "\" -B\""; args += "\" -B\"";
args += cmSystemTools::HandleNetworkPaths(m_Makefile->GetHomeOutputDirectory()); args +=
cmSystemTools::ConvertToOutputPath(m_Makefile->GetHomeOutputDirectory());
args += "\""; args += "\"";
m_Makefile->ExpandVariablesInString(args); m_Makefile->ExpandVariablesInString(args);
@ -268,7 +270,8 @@ void cmDSPWriter::WriteDSPFile(std::ostream& fout,
// Tell MS-Dev what the source is. If the compiler knows how to // Tell MS-Dev what the source is. If the compiler knows how to
// build it, then it will. // build it, then it will.
fout << "SOURCE=" << cmSystemTools::EscapeSpaces(source.c_str()) << "\n\n"; fout << "SOURCE=" <<
cmSystemTools::ConvertToOutputPath(source.c_str()) << "\n\n";
if (!commands.empty()) if (!commands.empty())
{ {
cmSourceGroup::CommandFiles totalCommand; cmSourceGroup::CommandFiles totalCommand;
@ -315,12 +318,11 @@ void cmDSPWriter::WriteCustomRule(std::ostream& fout,
// Write out the dependencies for the rule. // Write out the dependencies for the rule.
fout << "USERDEP__HACK="; fout << "USERDEP__HACK=";
std::string temp;
for(std::set<std::string>::const_iterator d = depends.begin(); for(std::set<std::string>::const_iterator d = depends.begin();
d != depends.end(); ++d) d != depends.end(); ++d)
{ {
temp = *d; fout << "\\\n\t" <<
fout << "\\\n\t" << cmSystemTools::EscapeSpaces(cmSystemTools::ConvertToWindowsSlashes(temp)); cmSystemTools::ConvertToOutputPath(d->c_str());
} }
fout << "\n"; fout << "\n";
@ -455,8 +457,7 @@ cmDSPWriter::CombineCommands(const cmSourceGroup::Commands &commands,
{ {
totalCommandStr += "\n\t"; totalCommandStr += "\n\t";
temp= c->second.m_Command; temp= c->second.m_Command;
cmSystemTools::ConvertToWindowsSlashes(temp); temp = cmSystemTools::ConvertToOutputPath(temp.c_str());
temp = cmSystemTools::EscapeSpaces(temp.c_str());
totalCommandStr += temp; totalCommandStr += temp;
totalCommandStr += " "; totalCommandStr += " ";
totalCommandStr += c->second.m_Arguments; totalCommandStr += c->second.m_Arguments;
@ -556,7 +557,8 @@ void cmDSPWriter::WriteDSPHeader(std::ostream& fout, const char *libName,
{ {
libPath += "/"; libPath += "/";
} }
std::string lpath = cmSystemTools::HandleNetworkPaths(libPath.c_str()); std::string lpath =
cmSystemTools::ConvertToOutputPath(libPath.c_str());
if(pathEmitted.insert(lpath).second) if(pathEmitted.insert(lpath).second)
{ {
libOptions += " /LIBPATH:\""; libOptions += " /LIBPATH:\"";
@ -580,7 +582,8 @@ void cmDSPWriter::WriteDSPHeader(std::ostream& fout, const char *libName,
{ {
exePath += "/"; exePath += "/";
} }
std::string lpath = cmSystemTools::HandleNetworkPaths(exePath.c_str()); std::string lpath =
cmSystemTools::ConvertToOutputPath(exePath.c_str());
if(pathEmitted.insert(lpath).second) if(pathEmitted.insert(lpath).second)
{ {
libOptions += " /LIBPATH:\""; libOptions += " /LIBPATH:\"";
@ -601,7 +604,8 @@ void cmDSPWriter::WriteDSPHeader(std::ostream& fout, const char *libName,
std::vector<std::string>& libdirs = m_Makefile->GetLinkDirectories(); std::vector<std::string>& libdirs = m_Makefile->GetLinkDirectories();
for(i = libdirs.begin(); i != libdirs.end(); ++i) for(i = libdirs.begin(); i != libdirs.end(); ++i)
{ {
std::string lpath = cmSystemTools::HandleNetworkPaths(i->c_str()); std::string lpath =
cmSystemTools::ConvertToOutputPath(i->c_str());
if(lpath[lpath.size()-1] != '/') if(lpath[lpath.size()-1] != '/')
{ {
lpath += "/"; lpath += "/";
@ -640,7 +644,7 @@ void cmDSPWriter::WriteDSPHeader(std::ostream& fout, const char *libName,
{ {
lib += ".lib"; lib += ".lib";
} }
lib = cmSystemTools::EscapeSpaces(lib.c_str()); lib = cmSystemTools::ConvertToOutputPath(lib.c_str());
if (j->second == cmTarget::GENERAL) if (j->second == cmTarget::GENERAL)
{ {
@ -725,9 +729,9 @@ void cmDSPWriter::WriteDSPHeader(std::ostream& fout, const char *libName,
m_IncludeOptions.c_str()); m_IncludeOptions.c_str());
cmSystemTools::ReplaceString(line, "OUTPUT_LIBNAME",libName); cmSystemTools::ReplaceString(line, "OUTPUT_LIBNAME",libName);
cmSystemTools::ReplaceString(line, "LIBRARY_OUTPUT_PATH", cmSystemTools::ReplaceString(line, "LIBRARY_OUTPUT_PATH",
cmSystemTools::HandleNetworkPaths(libPath.c_str()).c_str()); cmSystemTools::ConvertToOutputPath(libPath.c_str()).c_str());
cmSystemTools::ReplaceString(line, "EXECUTABLE_OUTPUT_PATH", cmSystemTools::ReplaceString(line, "EXECUTABLE_OUTPUT_PATH",
cmSystemTools::HandleNetworkPaths(exePath.c_str()).c_str()); cmSystemTools::ConvertToOutputPath(exePath.c_str()).c_str());
cmSystemTools::ReplaceString(line, cmSystemTools::ReplaceString(line,
"EXTRA_DEFINES", "EXTRA_DEFINES",
m_Makefile->GetDefineFlags()); m_Makefile->GetDefineFlags());

2
Source/cmExecProgramCommand.cxx
View File

@ -34,7 +34,7 @@ bool cmExecProgramCommand::InitialPass(std::vector<std::string> const& argsIn)
cmSystemTools::MakeDirectory(args[1].c_str()); cmSystemTools::MakeDirectory(args[1].c_str());
std::string command; std::string command;
command = "cd "; command = "cd ";
command += args[1].c_str(); command += cmSystemTools::ConvertToOutputPath(args[1].c_str());
command += " && "; command += " && ";
command += args[0].c_str(); command += args[0].c_str();
cmSystemTools::RunCommand(command.c_str(), output); cmSystemTools::RunCommand(command.c_str(), output);

46
Source/cmMSDotNETGenerator.cxx
View File

@ -306,8 +306,7 @@ void cmMSDotNETGenerator::WriteProject(std::ostream& fout,
const cmTarget& target const cmTarget& target
) )
{ {
std::string d = dir; std::string d = cmSystemTools::ConvertToOutputPath(dir);
cmSystemTools::ConvertToWindowsSlashes(d);
fout << "Project(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\" = \"" fout << "Project(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\" = \""
<< dspname << "\", \"" << dspname << "\", \""
<< d << "\\" << dspname << ".vcproj\", \"{" << d << "\\" << dspname << ".vcproj\", \"{"
@ -485,7 +484,8 @@ void cmMSDotNETGenerator::OutputVCProjFile()
{ {
m_LibraryOutputPath += "/"; m_LibraryOutputPath += "/";
} }
m_LibraryOutputPath = cmSystemTools::HandleNetworkPaths(m_LibraryOutputPath.c_str()); m_LibraryOutputPath =
cmSystemTools::ConvertToOutputPath(m_LibraryOutputPath.c_str());
} }
m_ExecutableOutputPath = ""; m_ExecutableOutputPath = "";
if (m_Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH")) if (m_Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH"))
@ -500,14 +500,14 @@ void cmMSDotNETGenerator::OutputVCProjFile()
m_ExecutableOutputPath += "/"; m_ExecutableOutputPath += "/";
} }
} }
m_ExecutableOutputPath = cmSystemTools::HandleNetworkPaths(m_ExecutableOutputPath.c_str()); m_ExecutableOutputPath =
cmSystemTools::ConvertToOutputPath(m_ExecutableOutputPath.c_str());
std::vector<std::string>& includes = m_Makefile->GetIncludeDirectories(); std::vector<std::string>& includes = m_Makefile->GetIncludeDirectories();
std::vector<std::string>::iterator i; std::vector<std::string>::iterator i;
for(i = includes.begin(); i != includes.end(); ++i) for(i = includes.begin(); i != includes.end(); ++i)
{ {
std::string tmp = cmSystemTools::EscapeSpaces(i->c_str()); std::string tmp = cmSystemTools::ConvertToOutputPath(i->c_str());
cmSystemTools::ConvertToWindowsSlashesAndCleanUp(tmp);
m_IncludeOptions += ","; m_IncludeOptions += ",";
// quote if not already quoted // quote if not already quoted
if (tmp[0] != '"') if (tmp[0] != '"')
@ -578,20 +578,23 @@ void cmMSDotNETGenerator::AddVCProjBuildRule(cmSourceGroup& sourceGroup)
std::string makefileIn = m_Makefile->GetStartDirectory(); std::string makefileIn = m_Makefile->GetStartDirectory();
makefileIn += "/"; makefileIn += "/";
makefileIn += "CMakeLists.txt"; makefileIn += "CMakeLists.txt";
makefileIn = cmSystemTools::HandleNetworkPaths(makefileIn.c_str()); makefileIn = cmSystemTools::ConvertToOutputPath(makefileIn.c_str());
makefileIn = cmSystemTools::EscapeSpaces(makefileIn.c_str());
std::string dsprule = "${CMAKE_COMMAND}"; std::string dsprule = "${CMAKE_COMMAND}";
m_Makefile->ExpandVariablesInString(dsprule); m_Makefile->ExpandVariablesInString(dsprule);
dsprule = cmSystemTools::HandleNetworkPaths(dsprule.c_str()); dsprule = cmSystemTools::ConvertToOutputPath(dsprule.c_str());
std::string args = makefileIn; std::string args = makefileIn;
args += " -H\""; args += " -H\"";
args += cmSystemTools::HandleNetworkPaths(m_Makefile->GetHomeDirectory()); args +=
cmSystemTools::ConvertToOutputPath(m_Makefile->GetHomeDirectory());
args += "\" -S\""; args += "\" -S\"";
args += cmSystemTools::HandleNetworkPaths(m_Makefile->GetStartDirectory()); args +=
cmSystemTools::ConvertToOutputPath(m_Makefile->GetStartDirectory());
args += "\" -O\""; args += "\" -O\"";
args += cmSystemTools::HandleNetworkPaths(m_Makefile->GetStartOutputDirectory()); args +=
cmSystemTools::ConvertToOutputPath(m_Makefile->GetStartOutputDirectory());
args += "\" -B\""; args += "\" -B\"";
args += cmSystemTools::HandleNetworkPaths(m_Makefile->GetHomeOutputDirectory()); args +=
cmSystemTools::ConvertToOutputPath(m_Makefile->GetHomeOutputDirectory());
args += "\""; args += "\"";
m_Makefile->ExpandVariablesInString(args); m_Makefile->ExpandVariablesInString(args);
@ -824,7 +827,7 @@ void cmMSDotNETGenerator::OutputLibraryDirectories(std::ostream& fout,
std::vector<std::string>& libdirs = m_Makefile->GetLinkDirectories(); std::vector<std::string>& libdirs = m_Makefile->GetLinkDirectories();
for(i = libdirs.begin(); i != libdirs.end(); ++i) for(i = libdirs.begin(); i != libdirs.end(); ++i)
{ {
std::string lpath = cmSystemTools::HandleNetworkPaths(i->c_str()); std::string lpath = cmSystemTools::ConvertToOutputPath(i->c_str());
if(lpath[lpath.size()-1] != '/') if(lpath[lpath.size()-1] != '/')
{ {
lpath += "/"; lpath += "/";
@ -855,7 +858,7 @@ void cmMSDotNETGenerator::OutputLibraries(std::ostream& fout,
{ {
lib += ".lib"; lib += ".lib";
} }
lib = cmSystemTools::EscapeSpaces(lib.c_str()); lib = cmSystemTools::ConvertToOutputPath(lib.c_str());
if (j->second == cmTarget::GENERAL if (j->second == cmTarget::GENERAL
|| (j->second == cmTarget::DEBUG && strcmp(configName, "DEBUG") == 0) || (j->second == cmTarget::DEBUG && strcmp(configName, "DEBUG") == 0)
|| (j->second == cmTarget::OPTIMIZED && strcmp(configName, "DEBUG") != 0)) || (j->second == cmTarget::OPTIMIZED && strcmp(configName, "DEBUG") != 0))
@ -968,11 +971,10 @@ void cmMSDotNETGenerator::WriteVCProjFile(std::ostream& fout,
if (source != libName || target.GetType() == cmTarget::UTILITY) if (source != libName || target.GetType() == cmTarget::UTILITY)
{ {
fout << "\t\t\t<File\n"; fout << "\t\t\t<File\n";
std::string d = source; std::string d = cmSystemTools::ConvertToOutputPath(source.c_str());
cmSystemTools::ConvertToWindowsSlashes(d);
// Tell MS-Dev what the source is. If the compiler knows how to // Tell MS-Dev what the source is. If the compiler knows how to
// build it, then it will. // build it, then it will.
fout << "\t\t\t\tRelativePath=\"" << cmSystemTools::EscapeSpaces(d.c_str()) << "\">\n"; fout << "\t\t\t\tRelativePath=\"" << d << "\">\n";
if (!commands.empty()) if (!commands.empty())
{ {
cmSourceGroup::CommandFiles totalCommand; cmSourceGroup::CommandFiles totalCommand;
@ -1022,8 +1024,7 @@ void cmMSDotNETGenerator::WriteCustomRule(std::ostream& fout,
for(std::set<std::string>::const_iterator d = depends.begin(); for(std::set<std::string>::const_iterator d = depends.begin();
d != depends.end(); ++d) d != depends.end(); ++d)
{ {
temp = *d; fout << cmSystemTools::ConvertToOutputPath(d->c_str())
fout << cmSystemTools::EscapeSpaces(cmSystemTools::ConvertToWindowsSlashes(temp))
<< ";"; << ";";
} }
fout << "\"\n"; fout << "\"\n";
@ -1087,9 +1088,8 @@ cmMSDotNETGenerator::CombineCommands(const cmSourceGroup::Commands &commands,
for(cmSourceGroup::Commands::const_iterator c = commands.begin(); for(cmSourceGroup::Commands::const_iterator c = commands.begin();
c != commands.end(); ++c) c != commands.end(); ++c)
{ {
temp= c->second.m_Command; temp=
cmSystemTools::ConvertToWindowsSlashes(temp); cmSystemTools::ConvertToOutputPath(c->second.m_Command.c_str());
temp = cmSystemTools::EscapeSpaces(temp.c_str());
totalCommandStr += temp; totalCommandStr += temp;
totalCommandStr += " "; totalCommandStr += " ";
totalCommandStr += c->second.m_Arguments; totalCommandStr += c->second.m_Arguments;

84
Source/cmNMakeMakefileGenerator.cxx
View File

@ -44,11 +44,11 @@ cmNMakeMakefileGenerator::~cmNMakeMakefileGenerator()
std::string cmNMakeMakefileGenerator::ShortPath(const char* path) std::string cmNMakeMakefileGenerator::ShortPath(const char* path)
{ {
std::string ret = path; std::string ret = path;
cmSystemTools::ConvertToWindowsSlashes(ret); // if there are no spaces in path, then just
// if there are no spaces in path, then just return path // call ConvertToOutputPath
if(ret.find(' ') == std::string::npos) if(ret.find(' ') == std::string::npos)
{ {
return ret; return this->ConvertToOutputPath(path);
} }
// if there are spaces then call GetShortPathName to get rid of them // if there are spaces then call GetShortPathName to get rid of them
@ -61,8 +61,8 @@ std::string cmNMakeMakefileGenerator::ShortPath(const char* path)
else else
{ {
// if GetShortPathName failed for some reason use // if GetShortPathName failed for some reason use
// EscapeSpaces instead // ConvertToOutputPath instead which will at least escape the spaces
ret = cmSystemTools::EscapeSpaces(path); ret = this->ConvertToOutputPath(path);
} }
delete [] buffer; delete [] buffer;
return ret; return ret;
@ -87,7 +87,7 @@ std::string cmNMakeMakefileGenerator::ShortPathCommand(const char* command)
{ {
c = removeIntDir.match(1) + removeIntDir.match(2); c = removeIntDir.match(1) + removeIntDir.match(2);
} }
c = ShortPath(c.c_str()); c = this->ShortPath(c.c_str());
std::string ret = c; std::string ret = c;
std::string args = reg.match(2); std::string args = reg.match(2);
ret += args; ret += args;
@ -159,24 +159,24 @@ void cmNMakeMakefileGenerator::OutputMakeVariables(std::ostream& fout)
fout << replaceVars.c_str(); fout << replaceVars.c_str();
std::string ccompiler = m_Makefile->GetDefinition("CMAKE_C_COMPILER"); std::string ccompiler = m_Makefile->GetDefinition("CMAKE_C_COMPILER");
cmSystemTools::ConvertToWindowsSlashes(ccompiler); fout << "CMAKE_C_COMPILER = "
fout << "CMAKE_C_COMPILER = " << cmSystemTools::EscapeSpaces(ccompiler.c_str()) << "\n"; << this->ConvertToOutputPath(ccompiler.c_str()) << "\n";
std::string cxxcompiler = m_Makefile->GetDefinition("CMAKE_CXX_COMPILER"); std::string cxxcompiler = m_Makefile->GetDefinition("CMAKE_CXX_COMPILER");
cmSystemTools::ConvertToWindowsSlashes(cxxcompiler); fout << "CMAKE_CXX_COMPILER = "
fout << "CMAKE_CXX_COMPILER = " << cmSystemTools::EscapeSpaces(cxxcompiler.c_str()) << "\n"; << this->ConvertToOutputPath(cxxcompiler.c_str()) << "\n";
std::string linker = m_Makefile->GetDefinition("CMAKE_LINKER"); std::string linker = m_Makefile->GetDefinition("CMAKE_LINKER");
cmSystemTools::ConvertToWindowsSlashes(linker); fout << "CMAKE_LINKER = " <<
fout << "CMAKE_LINKER = " << cmSystemTools::EscapeSpaces(linker.c_str()) << "\n"; this->ConvertToOutputPath(linker.c_str()) << "\n";
std::string lib_manager = m_Makefile->GetDefinition("CMAKE_LIBRARY_MANAGER"); std::string lib_manager = m_Makefile->GetDefinition("CMAKE_LIBRARY_MANAGER");
cmSystemTools::ConvertToWindowsSlashes(lib_manager); fout << "CMAKE_LIBRARY_MANAGER = "
fout << "CMAKE_LIBRARY_MANAGER = " << cmSystemTools::EscapeSpaces(lib_manager.c_str()) << "\n"; << this->ConvertToOutputPath(lib_manager.c_str()) << "\n";
std::string cmakecommand = m_Makefile->GetDefinition("CMAKE_COMMAND"); std::string cmakecommand = m_Makefile->GetDefinition("CMAKE_COMMAND");
cmSystemTools::ConvertToWindowsSlashes(cmakecommand); fout << "CMAKE_COMMAND = "
fout << "CMAKE_COMMAND = " << cmSystemTools::EscapeSpaces(cmakecommand.c_str()) << "\n"; << this->ConvertToOutputPath(cmakecommand.c_str()) << "\n";
fout << "CMAKE_CURRENT_SOURCE = " fout << "CMAKE_CURRENT_SOURCE = "
<< ShortPath(m_Makefile->GetStartDirectory() ) << ShortPath(m_Makefile->GetStartDirectory() )
@ -194,17 +194,15 @@ void cmNMakeMakefileGenerator::OutputMakeVariables(std::ostream& fout)
fout << "INCLUDE_FLAGS = "; fout << "INCLUDE_FLAGS = ";
std::vector<std::string>& includes = m_Makefile->GetIncludeDirectories(); std::vector<std::string>& includes = m_Makefile->GetIncludeDirectories();
std::vector<std::string>::iterator i; std::vector<std::string>::iterator i;
fout << "-I" << cmSystemTools::EscapeSpaces(m_Makefile->GetStartDirectory()) << " "; fout << "-I" <<
this->ConvertToOutputPath(m_Makefile->GetStartDirectory()) << " ";
for(i = includes.begin(); i != includes.end(); ++i) for(i = includes.begin(); i != includes.end(); ++i)
{ {
std::string include = *i; std::string include = *i;
// Don't output a -I for the standard include path "/usr/include". // Don't output a -I for the standard include path "/usr/include".
// This can cause problems with certain standard library // This can cause problems with certain standard library
// implementations because the wrong headers may be found first. // implementations because the wrong headers may be found first.
if(include != "/usr/include") fout << "-I" << this->ConvertToOutputPath(i->c_str()).c_str() << " ";
{
fout << "-I" << cmSystemTools::EscapeSpaces(i->c_str()).c_str() << " ";
}
} }
fout << m_Makefile->GetDefineFlags(); fout << m_Makefile->GetDefineFlags();
@ -219,9 +217,7 @@ void cmNMakeMakefileGenerator::BuildInSubDirectory(std::ostream& fout,
{ {
if(target1) if(target1)
{ {
std::string dir = directory; std::string dir = this->ConvertToOutputPath(directory);
cmSystemTools::ConvertToWindowsSlashes(dir);
dir = cmSystemTools::EscapeSpaces(dir.c_str());
fout << "\tif not exist \"" << dir << "\\$(NULL)\"" fout << "\tif not exist \"" << dir << "\\$(NULL)\""
<< " " << " "
<< "$(MAKE) $(MAKESILENT) rebuild_cache\n" << "$(MAKE) $(MAKESILENT) rebuild_cache\n"
@ -235,8 +231,7 @@ void cmNMakeMakefileGenerator::BuildInSubDirectory(std::ostream& fout,
fout << "\t$(MAKE) -$(MAKEFLAGS) $(MAKESILENT) " << target2 << "\n"; fout << "\t$(MAKE) -$(MAKEFLAGS) $(MAKESILENT) " << target2 << "\n";
} }
std::string currentDir = m_Makefile->GetCurrentOutputDirectory(); std::string currentDir = m_Makefile->GetCurrentOutputDirectory();
cmSystemTools::ConvertToWindowsSlashes(currentDir); fout << "\tcd " << this->ConvertToOutputPath(currentDir.c_str()) << "\n\n";
fout << "\tcd " << cmSystemTools::EscapeSpaces(currentDir.c_str()) << "\n\n";
} }
@ -272,7 +267,7 @@ void cmNMakeMakefileGenerator::OutputMakeRule(std::ostream& fout,
fout << "\n"; fout << "\n";
replace = target; replace = target;
m_Makefile->ExpandVariablesInString(replace); m_Makefile->ExpandVariablesInString(replace);
replace = cmSystemTools::EscapeSpaces(replace.c_str()); replace = this->ConvertToOutputPath(replace.c_str());
fout << replace.c_str() << ": "; fout << replace.c_str() << ": ";
if(depends) if(depends)
{ {
@ -358,7 +353,7 @@ OutputBuildObjectFromSource(std::ostream& fout,
} }
compileCommand += "$(INCLUDE_FLAGS) -c "; compileCommand += "$(INCLUDE_FLAGS) -c ";
compileCommand += compileCommand +=
cmSystemTools::EscapeSpaces(source.GetFullPath().c_str()); this->ConvertToOutputPath(source.GetFullPath().c_str());
// Need to get the definition here because this value might have // Need to get the definition here because this value might have
// trailing space (since it is directly prepended to the filename) // trailing space (since it is directly prepended to the filename)
@ -375,7 +370,7 @@ OutputBuildObjectFromSource(std::ostream& fout,
compileCommand += objectFile; compileCommand += objectFile;
compileCommand += "\" "; compileCommand += "\" ";
compileCommand += compileCommand +=
cmSystemTools::EscapeSpaces(source.GetFullPath().c_str()); this->ConvertToOutputPath(source.GetFullPath().c_str());
} }
else if (ext == "def") else if (ext == "def")
{ {
@ -394,7 +389,7 @@ OutputBuildObjectFromSource(std::ostream& fout,
} }
compileCommand += "$(INCLUDE_FLAGS) -c "; compileCommand += "$(INCLUDE_FLAGS) -c ";
compileCommand += compileCommand +=
cmSystemTools::EscapeSpaces(source.GetFullPath().c_str()); this->ConvertToOutputPath(source.GetFullPath().c_str());
// Need to get the definition here because this value might have // Need to get the definition here because this value might have
// trailing space (since it is directly prepended to the filename) // trailing space (since it is directly prepended to the filename)
@ -409,7 +404,7 @@ OutputBuildObjectFromSource(std::ostream& fout,
this->OutputMakeRule(fout, this->OutputMakeRule(fout,
comment.c_str(), comment.c_str(),
objectFile.c_str(), objectFile.c_str(),
cmSystemTools::EscapeSpaces( this->ConvertToOutputPath(
source.GetFullPath().c_str()).c_str(), source.GetFullPath().c_str()).c_str(),
compileCommand.c_str()); compileCommand.c_str());
} }
@ -440,7 +435,7 @@ void cmNMakeMakefileGenerator::OutputSharedLibraryRule(std::ostream& fout,
command += " $(CMAKE_LINKER_FLAGS) " + linker_output_file_flag; command += " $(CMAKE_LINKER_FLAGS) " + linker_output_file_flag;
std::string dllpath = m_LibraryOutputPath + std::string(name) + m_SharedLibraryExtension; std::string dllpath = m_LibraryOutputPath + std::string(name) + m_SharedLibraryExtension;
command += cmSystemTools::EscapeSpaces(dllpath.c_str()); command += this->ConvertToOutputPath(dllpath.c_str());
command += " $(" + this->CreateMakeVariable(name, "_SRC_OBJS") + ") "; command += " $(" + this->CreateMakeVariable(name, "_SRC_OBJS") + ") ";
@ -503,7 +498,7 @@ void cmNMakeMakefileGenerator::OutputStaticLibraryRule(std::ostream& fout,
std::string command = "$(CMAKE_LIBRARY_MANAGER) $(CMAKE_LIBRARY_MANAGER_FLAGS) @<<\n\t " + library_manager_output_file_flag; std::string command = "$(CMAKE_LIBRARY_MANAGER) $(CMAKE_LIBRARY_MANAGER_FLAGS) @<<\n\t " + library_manager_output_file_flag;
std::string libpath = m_LibraryOutputPath + std::string(name) + m_StaticLibraryExtension; std::string libpath = m_LibraryOutputPath + std::string(name) + m_StaticLibraryExtension;
command += cmSystemTools::EscapeSpaces(libpath.c_str()); command += this->ConvertToOutputPath(libpath.c_str());
command += " $("; command += " $(";
command += this->CreateMakeVariable(name, "_SRC_OBJS") + ")"; command += this->CreateMakeVariable(name, "_SRC_OBJS") + ")";
@ -546,7 +541,7 @@ void cmNMakeMakefileGenerator::OutputExecutableRule(std::ostream& fout,
m_Makefile->ExpandVariablesInString(output_executable_file_flag); m_Makefile->ExpandVariablesInString(output_executable_file_flag);
command += " " + output_executable_file_flag + command += " " + output_executable_file_flag +
cmSystemTools::EscapeSpaces(path.c_str()); this->ConvertToOutputPath(path.c_str());
command += " $(CMAKE_C_LINK_EXECUTABLE_FLAG) "; command += " $(CMAKE_C_LINK_EXECUTABLE_FLAG) ";
if(t.GetType() == cmTarget::WIN32_EXECUTABLE) if(t.GetType() == cmTarget::WIN32_EXECUTABLE)
@ -605,7 +600,7 @@ void cmNMakeMakefileGenerator::OutputLinkLibraries(std::ostream& fout,
if(emitted.insert(libpath).second) if(emitted.insert(libpath).second)
{ {
linkLibs += lib_path_opt; linkLibs += lib_path_opt;
cmSystemTools::ConvertToWindowsSlashes(libpath); this->ConvertToOutputPath(libpath.c_str());
linkLibs += libpath; linkLibs += libpath;
linkLibs += " "; linkLibs += " ";
} }
@ -698,26 +693,21 @@ void cmNMakeMakefileGenerator::OutputBuildLibraryInDir(std::ostream& fout,
const char* fullpath) const char* fullpath)
{ {
std::string currentDir = m_Makefile->GetCurrentOutputDirectory(); std::string currentDir =
cmSystemTools::ConvertToWindowsSlashes(currentDir); this->ConvertToOutputPath(m_Makefile->GetCurrentOutputDirectory());
std::string wpath = cmSystemTools::EscapeSpaces(path); std::string wpath = this->ConvertToOutputPath(path);
cmSystemTools::ConvertToWindowsSlashes(wpath); std::string wfullpath = this->ConvertToOutputPath(fullpath);
std::string wfullpath = cmSystemTools::EscapeSpaces(fullpath);
cmSystemTools::ConvertToWindowsSlashes(wfullpath);
fout << wfullpath fout << wfullpath
<< ":\n\tcd " << wpath << "\n" << ":\n\tcd " << wpath << "\n"
<< "\t$(MAKE) -$(MAKEFLAGS) $(MAKESILENT) cmake.depends\n" << "\t$(MAKE) -$(MAKEFLAGS) $(MAKESILENT) cmake.depends\n"
<< "\t$(MAKE) -$(MAKEFLAGS) $(MAKESILENT) cmake.check_depends\n" << "\t$(MAKE) -$(MAKEFLAGS) $(MAKESILENT) cmake.check_depends\n"
<< "\t$(MAKE) -$(MAKEFLAGS) $(MAKESILENT) -f cmake.check_depends\n" << "\t$(MAKE) -$(MAKEFLAGS) $(MAKESILENT) -f cmake.check_depends\n"
<< "\t$(MAKE) $(MAKESILENT) " << wfullpath << "\t$(MAKE) $(MAKESILENT) " << wfullpath
<< "\n\tcd " << << "\n\tcd " << currentDir << "\n";
cmSystemTools::EscapeSpaces(currentDir.c_str()) << "\n";
} }
std::string cmNMakeMakefileGenerator::ConvertToNativePath(const char* s) std::string cmNMakeMakefileGenerator::ConvertToOutputPath(const char* s)
{ {
std::string ret = s; return cmSystemTools::ConvertToOutputPath(s);
cmSystemTools::ConvertToWindowsSlashes(ret);
return ret;
} }

2
Source/cmNMakeMakefileGenerator.h
View File

@ -86,7 +86,7 @@ protected:
virtual bool SamePath(const char* path1, const char* path2); virtual bool SamePath(const char* path1, const char* path2);
void SetLibraryPathOption(const char* lib){ m_LibraryPathOption = lib;} void SetLibraryPathOption(const char* lib){ m_LibraryPathOption = lib;}
void SetLibraryLinkOption(const char* lib){ m_LibraryLinkOption = lib;} void SetLibraryLinkOption(const char* lib){ m_LibraryLinkOption = lib;}
virtual std::string ConvertToNativePath(const char* s); virtual std::string ConvertToOutputPath(const char* s);
private: private:
std::string m_LibraryPathOption;// option to specifiy a link path -LIBPATH std::string m_LibraryPathOption;// option to specifiy a link path -LIBPATH
std::string m_LibraryLinkOption; // option to specify a library (like -l, empty for nmake) std::string m_LibraryLinkOption; // option to specify a library (like -l, empty for nmake)

177
Source/cmSystemTools.cxx
View File

@ -303,62 +303,7 @@ void cmSystemTools::ExpandRegistryValues(std::string& source)
} }
std::string cmSystemTools::HandleNetworkPaths(const char* str)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
std::string result;
// watch for network paths, MSVC can't seem to load //
if (strlen(str) > 2 && str[0] == '/' && str[1] == '/')
{
result = "\\\\";
result += (str + 2);
}
else
{
result += str;
}
#else
std::string result = "";
#endif
return result;
}
std::string cmSystemTools::EscapeSpaces(const char* str)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
std::string result;
// if there are spaces
std::string temp = str;
if (temp.find(" ") != std::string::npos)
{
// don't add quotes if they're already there
if (temp.find("\"")==std::string::npos)
{
result = "\"";
}
result += cmSystemTools::HandleNetworkPaths(str);
if (temp.find("\"")==std::string::npos)
{
result += "\"";
}
return result;
}
return cmSystemTools::HandleNetworkPaths(str);
#else
std::string result = "";
for(const char* ch = str; *ch != '\0'; ++ch)
{
if(*ch == ' ')
{
result += '\\';
}
result += *ch;
}
return result;
#endif
}
std::string cmSystemTools::EscapeQuotes(const char* str) std::string cmSystemTools::EscapeQuotes(const char* str)
{ {
@ -449,7 +394,7 @@ std::string cmSystemTools::UpperCase(const std::string& s)
// convert windows slashes to unix slashes \ with / // convert windows slashes to unix slashes \ with /
const char *cmSystemTools::ConvertToUnixSlashes(std::string& path) void cmSystemTools::ConvertToUnixSlashes(std::string& path)
{ {
std::string::size_type pos = 0; std::string::size_type pos = 0;
while((pos = path.find('\\', pos)) != std::string::npos) while((pos = path.find('\\', pos)) != std::string::npos)
@ -478,41 +423,113 @@ const char *cmSystemTools::ConvertToUnixSlashes(std::string& path)
{ {
path = path.substr(8); path = path.substr(8);
} }
return path.c_str();
} }
// convert windows slashes to unix slashes
const char *cmSystemTools::ConvertToWindowsSlashes(std::string& path) // change // to /, and escape any spaces in the path
std::string cmSystemTools::ConvertToUnixOutputPath(const char* path)
{ {
std::string ret = path;
// remove //
std::string::size_type pos = 0; std::string::size_type pos = 0;
while((pos = path.find('/', pos)) != std::string::npos) while((pos = ret.find("//", pos)) != std::string::npos)
{ {
path[pos] = '\\'; ret.erase(pos, 1);
}
// now escape spaces if there is a space in the path
if(ret.find(" ") != std::string::npos)
{
std::string result = "";
for(const char* ch = ret.c_str(); *ch != '\0'; ++ch)
{
if(*ch == ' ')
{
result += '\\';
}
result += *ch;
}
ret = result;
}
return ret;
}
std::string cmSystemTools::EscapeSpaces(const char* str)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
std::string result;
// if there are spaces
std::string temp = str;
if (temp.find(" ") != std::string::npos &&
temp.find("\"")==std::string::npos)
{
result = "\"";
result += str;
result += "\"";
return result;
}
return str;
#else
std::string result = "";
for(const char* ch = str; *ch != '\0'; ++ch)
{
if(*ch == ' ')
{
result += '\\';
}
result += *ch;
}
return result;
#endif
}
std::string cmSystemTools::ConvertToOutputPath(const char* path)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
return cmSystemTools::ConvertToWindowsOutputPath(path);
#else
return cmSystemTools::ConvertToUnixOutputPath(path);
#endif
}
// remove double slashes not at the start
std::string cmSystemTools::ConvertToWindowsOutputPath(const char* path)
{
std::string ret = path;
std::string::size_type pos = 0;
// first convert all of the slashes
while((pos = ret.find('/', pos)) != std::string::npos)
{
ret[pos] = '\\';
pos++; pos++;
} }
// remove any trailing slash // check for really small paths
if(path[path.size()-1] == '\\') if(ret.size() < 2)
{ {
path = path.substr(0, path.size()-1); return ret;
} }
return path.c_str(); // now clean up a bit and remove double slashes
} // Only if it is not the first position in the path which is a network
// path on windows
// convert Unix slashes to Windows slashes and cleanup double slashes pos = 1; // start at position 1
const char *cmSystemTools::ConvertToWindowsSlashesAndCleanUp(std::string& path) while((pos = ret.find("\\\\", pos)) != std::string::npos)
{
cmSystemTools::ConvertToWindowsSlashes(path);
std::string::size_type pos = 0;
if(path.size() > 1)
{ {
pos = 1; ret.erase(pos, 1);
while((pos = path.find("\\\\", pos)) != std::string::npos)
{
path.erase(pos, 1);
}
} }
return path.c_str(); // now double quote the path if it has spaces in it
// and is not already double quoted
if(ret.find(" ") != std::string::npos
&& ret[0] != '\"')
{
std::string result;
result = "\"" + ret + "\"";
ret = result;
}
return ret;
} }
bool cmSystemTools::ParseFunction(std::ifstream& fin, bool cmSystemTools::ParseFunction(std::ifstream& fin,

57
Source/cmSystemTools.h
View File

@ -48,23 +48,6 @@ public:
*/ */
static void ExpandRegistryValues(std::string& source); static void ExpandRegistryValues(std::string& source);
/**
* make sure on windows that paths with // are converted to \\
*/
static std::string HandleNetworkPaths(const char*);
/**
* Return a string equivalent to the input string, but with all " " replaced
* with "\ " to escape the spaces.
*/
static std::string EscapeSpaces(const char*);
/**
* Return a string equivalent to the input string, but with all " replaced
* with \" to escape the quote
*/
static std::string EscapeQuotes(const char*);
/** /**
* Return a capitalized string (i.e the first letter is uppercased, all other * Return a capitalized string (i.e the first letter is uppercased, all other
* are lowercased). * are lowercased).
@ -84,19 +67,23 @@ public:
/** /**
* Replace Windows file system slashes with Unix-style slashes. * Replace Windows file system slashes with Unix-style slashes.
*/ */
static const char *ConvertToUnixSlashes(std::string& path); static void ConvertToUnixSlashes(std::string& path);
/**
* Platform independent escape spaces, unix uses backslash,
* windows double quotes the string.
*/
static std::string EscapeSpaces(const char* str);
///! Escape quotes in a string.
static std::string EscapeQuotes(const char* str);
/** /**
* Replace Unix file system slashes with Windows-style slashes * For windows this calles ConvertToWindowsOutputPath and for unix
* it calls ConvertToUnixOutputPath
*/ */
static const char *ConvertToWindowsSlashes(std::string& path); static std::string ConvertToOutputPath(const char*);
/**
* Replace Unix file system slashes with Windows-style slashes and
* remove any duplicate \\ slashes to clean the path.
*/
static const char *ConvertToWindowsSlashesAndCleanUp(std::string& path);
///! Return true if a file exists in the current directory. ///! Return true if a file exists in the current directory.
static bool FileExists(const char* filename); static bool FileExists(const char* filename);
@ -265,7 +252,23 @@ public:
static void DisableMessages() { s_DisableMessages = true; } static void DisableMessages() { s_DisableMessages = true; }
static void DisableRunCommandOutput() {s_DisableRunCommandOutput = true; } static void DisableRunCommandOutput() {s_DisableRunCommandOutput = true; }
static void EnableRunCommandOutput() {s_DisableRunCommandOutput = false; } static void EnableRunCommandOutput() {s_DisableRunCommandOutput = false; }
protected:
// these two functions can be called from ConvertToOutputPath
/**
* Convert the path to a string that can be used in a unix makefile.
* double slashes are removed, and spaces are escaped.
*/
static std::string ConvertToUnixOutputPath(const char*);
/**
* Convert the path to string that can be used in a windows project or
* makefile. Double slashes are removed if they are not at the start of
* the string, the slashes are converted to windows style backslashes, and
* if there are spaces in the string it is double quoted.
*/
static std::string ConvertToWindowsOutputPath(const char*);
private: private:
static bool s_ErrorOccured; static bool s_ErrorOccured;
static bool s_DisableMessages; static bool s_DisableMessages;

79
Source/cmUnixMakefileGenerator.cxx
View File

@ -216,13 +216,12 @@ void cmUnixMakefileGenerator::OutputMakefile(const char* file)
for(std::vector<std::string>::const_iterator i = lfiles.begin(); for(std::vector<std::string>::const_iterator i = lfiles.begin();
i != lfiles.end(); ++i) i != lfiles.end(); ++i)
{ {
fout << " " << this->ConvertToNativePath(cmSystemTools::EscapeSpaces(i->c_str()).c_str()); fout << " " << this->ConvertToOutputPath(i->c_str());
} }
// Add the cache to the list // Add the cache to the list
std::string cacheFile = m_Makefile->GetHomeOutputDirectory(); std::string cacheFile = m_Makefile->GetHomeOutputDirectory();
cacheFile += "/CMakeCache.txt"; cacheFile += "/CMakeCache.txt";
fout << " " << fout << " " << this->ConvertToOutputPath(cacheFile.c_str());
this->ConvertToNativePath(cmSystemTools::EscapeSpaces(cacheFile.c_str()).c_str());
fout << "\n\n\n"; fout << "\n\n\n";
this->OutputMakeVariables(fout); this->OutputMakeVariables(fout);
// Set up the default target as the VERY first target, so that make with no arguments will run it // Set up the default target as the VERY first target, so that make with no arguments will run it
@ -314,21 +313,21 @@ void cmUnixMakefileGenerator::OutputTargetRules(std::ostream& fout)
{ {
path = path + l->first + m_StaticLibraryExtension; path = path + l->first + m_StaticLibraryExtension;
fout << " \\\n" fout << " \\\n"
<< this->ConvertToNativePath(cmSystemTools::EscapeSpaces(path.c_str()).c_str()); << this->ConvertToOutputPath(path.c_str());
} }
else if(l->second.GetType() == cmTarget::SHARED_LIBRARY) else if(l->second.GetType() == cmTarget::SHARED_LIBRARY)
{ {
path = path + l->first + path = path + l->first +
m_Makefile->GetDefinition("CMAKE_SHLIB_SUFFIX"); m_Makefile->GetDefinition("CMAKE_SHLIB_SUFFIX");
fout << " \\\n" fout << " \\\n"
<< this->ConvertToNativePath(cmSystemTools::EscapeSpaces(path.c_str()).c_str()); << this->ConvertToOutputPath(path.c_str());
} }
else if(l->second.GetType() == cmTarget::MODULE_LIBRARY) else if(l->second.GetType() == cmTarget::MODULE_LIBRARY)
{ {
path = path + l->first + path = path + l->first +
m_Makefile->GetDefinition("CMAKE_MODULE_SUFFIX"); m_Makefile->GetDefinition("CMAKE_MODULE_SUFFIX");
fout << " \\\n" fout << " \\\n"
<< this->ConvertToNativePath(cmSystemTools::EscapeSpaces(path.c_str()).c_str()); << this->ConvertToOutputPath(path.c_str());
} }
} }
} }
@ -342,7 +341,7 @@ void cmUnixMakefileGenerator::OutputTargetRules(std::ostream& fout)
{ {
std::string path = m_ExecutableOutputPath + l->first + std::string path = m_ExecutableOutputPath + l->first +
m_ExecutableExtension; m_ExecutableExtension;
fout << " \\\n" << this->ConvertToNativePath(cmSystemTools::EscapeSpaces(path.c_str()).c_str()); fout << " \\\n" << this->ConvertToOutputPath(path.c_str());
} }
} }
// list utilities last // list utilities last
@ -372,7 +371,7 @@ void cmUnixMakefileGenerator::OutputTargetRules(std::ostream& fout)
std::string outExt(this->GetOutputExtension(i->GetSourceExtension().c_str())); std::string outExt(this->GetOutputExtension(i->GetSourceExtension().c_str()));
if(outExt.size()) if(outExt.size())
{ {
fout << "\\\n" << this->ConvertToNativePath(i->GetSourceName().c_str()) fout << "\\\n" << this->ConvertToOutputPath(i->GetSourceName().c_str())
<< outExt.c_str() << " "; << outExt.c_str() << " ";
} }
} }
@ -387,7 +386,7 @@ void cmUnixMakefileGenerator::OutputTargetRules(std::ostream& fout)
std::string outExt(this->GetOutputExtension(i->GetSourceExtension().c_str())); std::string outExt(this->GetOutputExtension(i->GetSourceExtension().c_str()));
if(outExt.size()) if(outExt.size())
{ {
fout << "\\\n\"" << this->ConvertToNativePath(i->GetSourceName().c_str()) fout << "\\\n\"" << this->ConvertToOutputPath(i->GetSourceName().c_str())
<< outExt.c_str() << "\" "; << outExt.c_str() << "\" ";
} }
} }
@ -454,7 +453,7 @@ void cmUnixMakefileGenerator::OutputLinkLibraries(std::ostream& fout,
for(std::vector<std::string>::iterator libDir = libdirs.begin(); for(std::vector<std::string>::iterator libDir = libdirs.begin();
libDir != libdirs.end(); ++libDir) libDir != libdirs.end(); ++libDir)
{ {
std::string libpath = cmSystemTools::EscapeSpaces(libDir->c_str()); std::string libpath = this->ConvertToOutputPath(libDir->c_str());
if(emitted.insert(libpath).second) if(emitted.insert(libpath).second)
{ {
std::string::size_type pos = libDir->find("-L"); std::string::size_type pos = libDir->find("-L");
@ -492,7 +491,7 @@ void cmUnixMakefileGenerator::OutputLinkLibraries(std::ostream& fout,
std::string dir, file; std::string dir, file;
cmSystemTools::SplitProgramPath(lib->first.c_str(), cmSystemTools::SplitProgramPath(lib->first.c_str(),
dir, file); dir, file);
std::string libpath = cmSystemTools::EscapeSpaces(dir.c_str()); std::string libpath = this->ConvertToOutputPath(dir.c_str());
if(emitted.insert(libpath).second) if(emitted.insert(libpath).second)
{ {
linkLibs += "-L"; linkLibs += "-L";
@ -586,8 +585,7 @@ std::string cmUnixMakefileGenerator::CreateTargetRules(const cmTarget &target,
{ {
initNext = true; initNext = true;
} }
std::string command = cmSystemTools::EscapeSpaces(cc.GetCommand().c_str()); std::string command = this->ConvertToOutputPath(cc.GetCommand().c_str());
command = this->ConvertToNativePath(command.c_str());
customRuleCode += command + " " + cc.GetArguments(); customRuleCode += command + " " + cc.GetArguments();
} }
} }
@ -938,8 +936,8 @@ void cmUnixMakefileGenerator::OutputBuildLibraryInDir(std::ostream& fout,
{ {
makeTarget = fullpath; makeTarget = fullpath;
} }
fout << cmSystemTools::EscapeSpaces(fullpath) fout << this->ConvertToOutputPath(fullpath)
<< ":\n\tcd " << cmSystemTools::EscapeSpaces(path) << ":\n\tcd " << this->ConvertToOutputPath(path)
<< "; $(MAKE) -$(MAKEFLAGS) $(MAKESILENT) cmake.depends" << "; $(MAKE) -$(MAKEFLAGS) $(MAKESILENT) cmake.depends"
<< "; $(MAKE) -$(MAKEFLAGS) $(MAKESILENT) cmake.check_depends" << "; $(MAKE) -$(MAKEFLAGS) $(MAKESILENT) cmake.check_depends"
<< "; $(MAKE) -$(MAKEFLAGS) $(MAKESILENT) -f cmake.check_depends" << "; $(MAKE) -$(MAKEFLAGS) $(MAKESILENT) -f cmake.check_depends"
@ -957,8 +955,8 @@ void cmUnixMakefileGenerator::OutputBuildExecutableInDir(std::ostream& fout,
{ {
makeTarget = fullpath; makeTarget = fullpath;
} }
fout << cmSystemTools::EscapeSpaces(fullpath) fout << this->ConvertToOutputPath(fullpath)
<< ":\n\tcd " << cmSystemTools::EscapeSpaces(path) << ":\n\tcd " << this->ConvertToOutputPath(path)
<< "; $(MAKE) -$(MAKEFLAGS) $(MAKESILENT) cmake.depends" << "; $(MAKE) -$(MAKEFLAGS) $(MAKESILENT) cmake.depends"
<< "; $(MAKE) -$(MAKEFLAGS) $(MAKESILENT) cmake.check_depends" << "; $(MAKE) -$(MAKEFLAGS) $(MAKESILENT) cmake.check_depends"
<< "; $(MAKE) -$(MAKEFLAGS) $(MAKESILENT) -f cmake.check_depends" << "; $(MAKE) -$(MAKEFLAGS) $(MAKESILENT) -f cmake.check_depends"
@ -1019,8 +1017,7 @@ void cmUnixMakefileGenerator::OutputLibDepend(std::ostream& fout,
{ {
libpath += m_StaticLibraryExtension; libpath += m_StaticLibraryExtension;
} }
fout << this->ConvertToNativePath(cmSystemTools::EscapeSpaces(libpath.c_str()).c_str()) fout << this->ConvertToOutputPath(libpath.c_str()) << " ";
<< " ";
} }
} }
@ -1066,8 +1063,7 @@ void cmUnixMakefileGenerator::OutputExeDepend(std::ostream& fout,
} }
exepath += replaceVars; exepath += replaceVars;
} }
fout << this->ConvertToNativePath(cmSystemTools::EscapeSpaces(exepath.c_str()).c_str()) fout << this->ConvertToOutputPath(exepath.c_str()) << " ";
<< " ";
} }
} }
@ -1100,7 +1096,7 @@ void cmUnixMakefileGenerator::BuildInSubDirectory(std::ostream& fout,
const char* target1, const char* target1,
const char* target2) const char* target2)
{ {
std::string directory = cmSystemTools::EscapeSpaces(dir); std::string directory = this->ConvertToOutputPath(dir);
if(target1) if(target1)
{ {
fout << "\t@if test ! -d " << directory fout << "\t@if test ! -d " << directory
@ -1241,8 +1237,7 @@ bool cmUnixMakefileGenerator::OutputObjectDepends(std::ostream& fout)
dep != source->GetDepends().end(); ++dep) dep != source->GetDepends().end(); ++dep)
{ {
fout << " \\\n" fout << " \\\n"
<< this->ConvertToNativePath(cmSystemTools::EscapeSpaces( << this->ConvertToOutputPath(dep->c_str());
dep->c_str()).c_str());
ret = true; ret = true;
} }
fout << "\n\n"; fout << "\n\n";
@ -1290,8 +1285,7 @@ void cmUnixMakefileGenerator::OutputCheckDepends(std::ostream& fout)
dep != source->GetDepends().end(); ++dep) dep != source->GetDepends().end(); ++dep)
{ {
std::string dependfile = std::string dependfile =
this->ConvertToNativePath(cmSystemTools::EscapeSpaces( this->ConvertToOutputPath(dep->c_str());
dep->c_str()).c_str());
if(emitted.insert(dependfile).second) if(emitted.insert(dependfile).second)
{ {
fout << " \\\n" << dependfile ; fout << " \\\n" << dependfile ;
@ -1371,9 +1365,8 @@ void cmUnixMakefileGenerator::OutputCustomRules(std::ostream& fout)
{ {
// escape spaces and convert to native slashes path for // escape spaces and convert to native slashes path for
// the command // the command
std::string command = std::string command =
cmSystemTools::EscapeSpaces(c->second.m_Command.c_str()); this->ConvertToOutputPath(c->second.m_Command.c_str());
command = this->ConvertToNativePath(command.c_str());
command += " "; command += " ";
// now add the arguments // now add the arguments
command += c->second.m_Arguments; command += c->second.m_Arguments;
@ -1388,7 +1381,7 @@ void cmUnixMakefileGenerator::OutputCustomRules(std::ostream& fout)
commandFiles.m_Depends.begin(); commandFiles.m_Depends.begin();
d != commandFiles.m_Depends.end(); ++d) d != commandFiles.m_Depends.end(); ++d)
{ {
std::string dep = cmSystemTools::EscapeSpaces(d->c_str()); std::string dep = this->ConvertToOutputPath(d->c_str());
depends += " "; depends += " ";
depends += dep; depends += dep;
} }
@ -1404,7 +1397,7 @@ void cmUnixMakefileGenerator::OutputCustomRules(std::ostream& fout)
commandFiles.m_Outputs.begin(); commandFiles.m_Outputs.begin();
output != commandFiles.m_Outputs.end(); ++output) output != commandFiles.m_Outputs.end(); ++output)
{ {
std::string src = cmSystemTools::EscapeSpaces(source.c_str()); std::string src = this->ConvertToOutputPath(source.c_str());
std::string depends; std::string depends;
depends += src; depends += src;
// Collect out all the dependencies for this rule. // Collect out all the dependencies for this rule.
@ -1412,7 +1405,7 @@ void cmUnixMakefileGenerator::OutputCustomRules(std::ostream& fout)
commandFiles.m_Depends.begin(); commandFiles.m_Depends.begin();
d != commandFiles.m_Depends.end(); ++d) d != commandFiles.m_Depends.end(); ++d)
{ {
std::string dep = cmSystemTools::EscapeSpaces(d->c_str()); std::string dep = this->ConvertToOutputPath(d->c_str());
depends += " "; depends += " ";
depends += dep; depends += dep;
} }
@ -1506,19 +1499,19 @@ void cmUnixMakefileGenerator::OutputMakeVariables(std::ostream& fout)
m_Makefile->ExpandVariablesInString(replaceVars); m_Makefile->ExpandVariablesInString(replaceVars);
fout << replaceVars.c_str(); fout << replaceVars.c_str();
fout << "CMAKE_CURRENT_SOURCE = " << fout << "CMAKE_CURRENT_SOURCE = " <<
cmSystemTools::EscapeSpaces(m_Makefile->GetStartDirectory()) << "\n"; this->ConvertToOutputPath(m_Makefile->GetStartDirectory()) << "\n";
fout << "CMAKE_CURRENT_BINARY = " << fout << "CMAKE_CURRENT_BINARY = " <<
cmSystemTools::EscapeSpaces(m_Makefile->GetStartOutputDirectory()) << "\n"; this->ConvertToOutputPath(m_Makefile->GetStartOutputDirectory()) << "\n";
fout << "CMAKE_SOURCE_DIR = " << fout << "CMAKE_SOURCE_DIR = " <<
cmSystemTools::EscapeSpaces(m_Makefile->GetHomeDirectory()) << "\n"; this->ConvertToOutputPath(m_Makefile->GetHomeDirectory()) << "\n";
fout << "CMAKE_BINARY_DIR = " << fout << "CMAKE_BINARY_DIR = " <<
cmSystemTools::EscapeSpaces(m_Makefile->GetHomeOutputDirectory()) << "\n"; this->ConvertToOutputPath(m_Makefile->GetHomeOutputDirectory()) << "\n";
// Output Include paths // Output Include paths
fout << "INCLUDE_FLAGS = "; fout << "INCLUDE_FLAGS = ";
std::vector<std::string>& includes = m_Makefile->GetIncludeDirectories(); std::vector<std::string>& includes = m_Makefile->GetIncludeDirectories();
std::vector<std::string>::iterator i; std::vector<std::string>::iterator i;
fout << "-I" << fout << "-I" <<
cmSystemTools::EscapeSpaces(m_Makefile->GetStartDirectory()) << " "; this->ConvertToOutputPath(m_Makefile->GetStartDirectory()) << " ";
for(i = includes.begin(); i != includes.end(); ++i) for(i = includes.begin(); i != includes.end(); ++i)
{ {
std::string include = *i; std::string include = *i;
@ -1527,7 +1520,7 @@ void cmUnixMakefileGenerator::OutputMakeVariables(std::ostream& fout)
// implementations because the wrong headers may be found first. // implementations because the wrong headers may be found first.
if(include != "/usr/include") if(include != "/usr/include")
{ {
fout << "-I" << cmSystemTools::EscapeSpaces(i->c_str()).c_str() << " "; fout << "-I" << this->ConvertToOutputPath(i->c_str()) << " ";
} }
} }
fout << m_Makefile->GetDefineFlags(); fout << m_Makefile->GetDefineFlags();
@ -1833,7 +1826,7 @@ OutputBuildObjectFromSource(std::ostream& fout,
} }
compileCommand += "$(INCLUDE_FLAGS) -c "; compileCommand += "$(INCLUDE_FLAGS) -c ";
compileCommand += compileCommand +=
cmSystemTools::EscapeSpaces(source.GetFullPath().c_str()); this->ConvertToOutputPath(source.GetFullPath().c_str());
compileCommand += " -o "; compileCommand += " -o ";
compileCommand += objectFile; compileCommand += objectFile;
} }
@ -1847,15 +1840,15 @@ OutputBuildObjectFromSource(std::ostream& fout,
} }
compileCommand += "$(INCLUDE_FLAGS) -c "; compileCommand += "$(INCLUDE_FLAGS) -c ";
compileCommand += compileCommand +=
cmSystemTools::EscapeSpaces(source.GetFullPath().c_str()); this->ConvertToOutputPath(source.GetFullPath().c_str());
compileCommand += " -o "; compileCommand += " -o ";
compileCommand += objectFile; compileCommand += objectFile;
} }
this->OutputMakeRule(fout, this->OutputMakeRule(fout,
comment.c_str(), comment.c_str(),
objectFile.c_str(), objectFile.c_str(),
cmSystemTools::EscapeSpaces(source.GetFullPath(). this->ConvertToOutputPath(source.GetFullPath().
c_str()).c_str(), c_str()).c_str(),
compileCommand.c_str()); compileCommand.c_str());
} }
@ -2057,7 +2050,7 @@ void cmUnixMakefileGenerator::ComputeSystemInfo()
// currently we run configure shell script here to determine the info // currently we run configure shell script here to determine the info
std::string output; std::string output;
std::string cmd = "cd "; std::string cmd = "cd ";
cmd += cmSystemTools::EscapeSpaces(m_Makefile->GetHomeOutputDirectory()); cmd += this->ConvertToOutputPath(m_Makefile->GetHomeOutputDirectory());
cmd += "; "; cmd += "; ";
const char* root const char* root
= m_Makefile->GetDefinition("CMAKE_ROOT"); = m_Makefile->GetDefinition("CMAKE_ROOT");

5
Source/cmUnixMakefileGenerator.h
View File

@ -153,7 +153,10 @@ protected:
void SetStaticLibraryExtension(const char* e) {m_StaticLibraryExtension = e;} void SetStaticLibraryExtension(const char* e) {m_StaticLibraryExtension = e;}
void SetSharedLibraryExtension(const char* e) {m_SharedLibraryExtension = e;} void SetSharedLibraryExtension(const char* e) {m_SharedLibraryExtension = e;}
void SetLibraryPrefix(const char* e) { m_LibraryPrefix = e;} void SetLibraryPrefix(const char* e) { m_LibraryPrefix = e;}
virtual std::string ConvertToNativePath(const char* s) { return s; } // convert a path to an output path for unix this will call
// ConvertToUnixOutputPath
virtual std::string ConvertToOutputPath(const char* s)
{ return cmSystemTools::ConvertToOutputPath(s); }
std::string CreateTargetRules(const cmTarget &target, std::string CreateTargetRules(const cmTarget &target,
const char* targetName); const char* targetName);
virtual std::string CreateMakeVariable(const char* s, const char* s2) virtual std::string CreateMakeVariable(const char* s, const char* s2)

10
Source/cmaketest.cxx
View File

@ -116,10 +116,7 @@ int main (int argc, char *argv[])
{ {
std::cerr << "Error: cmaketest does not have a valid MAKEPROGRAM\n"; std::cerr << "Error: cmaketest does not have a valid MAKEPROGRAM\n";
} }
makeCommand = cmSystemTools::EscapeSpaces(makeCommand.c_str()); makeCommand = cmSystemTools::ConvertToOutputPath(makeCommand.c_str());
#if defined(_WIN32) && !defined(__CYGWIN__)
cmSystemTools::ConvertToWindowsSlashes(makeCommand);
#endif
std::string lowerCaseCommand = makeCommand; std::string lowerCaseCommand = makeCommand;
cmSystemTools::LowerCase(lowerCaseCommand); cmSystemTools::LowerCase(lowerCaseCommand);
@ -246,10 +243,7 @@ int main (int argc, char *argv[])
cmSystemTools::ChangeDirectory(cwd.c_str()); cmSystemTools::ChangeDirectory(cwd.c_str());
return 1; return 1;
} }
fullPath = cmSystemTools::EscapeSpaces(fullPath.c_str()); fullPath = cmSystemTools::ConvertToOutputPath(fullPath.c_str());
#if defined(_WIN32) && !defined(__CYGWIN__)
cmSystemTools::ConvertToWindowsSlashes(fullPath);
#endif
std::cout << "Running test executable: " << fullPath.c_str() << "\n"; std::cout << "Running test executable: " << fullPath.c_str() << "\n";
int ret = 0; int ret = 0;
if (!cmSystemTools::RunCommand(fullPath.c_str(), output, ret, true)) if (!cmSystemTools::RunCommand(fullPath.c_str(), output, ret, true))