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

Merge topic 'remove-CMAKE_USE_RELATIVE_PATHS' 

6e570f85 cmLocalGenerator: Remove 'optional' parameter from Convert.
3d8c6cd9 cmLocalGenerator: Remove obsolete method.
e44e6bcc Port away from obsolete method.
1335992c Remove CMAKE_USE_RELATIVE_PATHS variable.
This commit is contained in:
Brad King 2015-06-04 09:13:33 -04:00 committed by CMake Topic Stage
parent 5a1c8806bf 6e570f857a
commit d6fe79f3ab
12 changed files with 96 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Help/release/dev/remove-CMAKE_USE_RELATIVE_PATHS.rst Normal file
View File

@ -0,0 +1,5 @@
remove-CMAKE_USE_RELATIVE_PATHS
-------------------------------
* The :variable:`CMAKE_USE_RELATIVE_PATHS` variable no longer has any
effect. Previously it was partially implemented and unreliable.

9
Help/variable/CMAKE_USE_RELATIVE_PATHS.rst
View File

@ -1,10 +1,5 @@
CMAKE_USE_RELATIVE_PATHS
------------------------
Use relative paths (May not work!).
If this is set to TRUE, then CMake will use relative paths between the
source and binary tree. This option does not work for more
complicated projects, and relative paths are used when possible. In
general, it is not possible to move CMake generated makefiles to a
different location regardless of the value of this variable.
This variable has no effect. The partially implemented effect it
had in previous releases was removed in CMake 3.4.

8
Source/cmGlobalVisualStudio8Generator.cxx
View File

@ -309,14 +309,10 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget()
cmCustomCommandLine commandLine;
commandLine.push_back(cmSystemTools::GetCMakeCommand());
std::string argH = "-H";
argH += lg->Convert(mf->GetHomeDirectory(),
cmLocalGenerator::START_OUTPUT,
cmLocalGenerator::UNCHANGED, true);
argH += mf->GetHomeDirectory();
commandLine.push_back(argH);
std::string argB = "-B";
argB += lg->Convert(mf->GetHomeOutputDirectory(),
cmLocalGenerator::START_OUTPUT,
cmLocalGenerator::UNCHANGED, true);
argB += mf->GetHomeOutputDirectory();
commandLine.push_back(argB);
commandLine.push_back("--check-stamp-list");
commandLine.push_back(stampList.c_str());

24
Source/cmGlobalXCodeGenerator.cxx
View File

@ -3804,33 +3804,13 @@ void cmGlobalXCodeGenerator::GetDocumentation(cmDocumentationEntry& entry)
//----------------------------------------------------------------------------
std::string cmGlobalXCodeGenerator::ConvertToRelativeForMake(const char* p)
{
if ( !this->CurrentMakefile->IsOn("CMAKE_USE_RELATIVE_PATHS") )
{
return cmSystemTools::ConvertToOutputPath(p);
}
else
{
std::string ret =
this->CurrentLocalGenerator->
ConvertToRelativePath(this->CurrentOutputDirectoryComponents, p);
return cmSystemTools::ConvertToOutputPath(ret.c_str());
}
return cmSystemTools::ConvertToOutputPath(p);
}
//----------------------------------------------------------------------------
std::string cmGlobalXCodeGenerator::ConvertToRelativeForXCode(const char* p)
{
if ( !this->CurrentMakefile->IsOn("CMAKE_USE_RELATIVE_PATHS") )
{
return cmSystemTools::ConvertToOutputPath(p);
}
else
{
std::string ret =
this->CurrentLocalGenerator->
ConvertToRelativePath(this->ProjectOutputDirectoryComponents, p);
return cmSystemTools::ConvertToOutputPath(ret.c_str());
}
return cmSystemTools::ConvertToOutputPath(p);
}
//----------------------------------------------------------------------------

88
Source/cmLocalGenerator.cxx
View File

@ -59,7 +59,6 @@ cmLocalGenerator::cmLocalGenerator(cmGlobalGenerator* gg,
this->Makefile = new cmMakefile(this);
this->LinkScriptShell = false;
this->UseRelativePaths = false;
this->Configured = false;
this->EmitUniversalBinaryFlags = true;
this->BackwardsCompatibility = 0;
@ -137,10 +136,6 @@ void cmLocalGenerator::Configure()
this->Makefile->AddCMakeDependFilesFromUser();
// Check whether relative paths should be used for optionally
// relative paths.
this->UseRelativePaths = this->Makefile->IsOn("CMAKE_USE_RELATIVE_PATHS");
this->ComputeObjectMaxPath();
this->Configured = true;
@ -522,7 +517,7 @@ void cmLocalGenerator::AddCustomCommandToCreateObject(const char* ofname,
objectDir = this->Convert(objectDir,START_OUTPUT,SHELL);
std::string objectFile = this->Convert(ofname,START_OUTPUT,SHELL);
std::string sourceFile =
this->Convert(source.GetFullPath(),START_OUTPUT,SHELL,true);
this->ConvertToOutputFormat(source.GetFullPath(), SHELL);
std::string varString = "CMAKE_";
varString += lang;
varString += "_COMPILE_OBJECT";
@ -1182,7 +1177,7 @@ cmLocalGenerator::ConvertToOutputForExistingCommon(const std::string& remote,
std::string tmp;
if(cmSystemTools::GetShortPath(remote, tmp))
{
return this->Convert(tmp, NONE, format, true);
return this->ConvertToOutputFormat(tmp, format);
}
}
@ -1196,8 +1191,10 @@ cmLocalGenerator::ConvertToOutputForExisting(const std::string& remote,
RelativeRoot local,
OutputFormat format)
{
static_cast<void>(local);
// Perform standard conversion.
std::string result = this->Convert(remote, local, format, true);
std::string result = this->ConvertToOutputFormat(remote, format);
// Consider short-path.
return this->ConvertToOutputForExistingCommon(remote, result, format);
@ -1316,8 +1313,7 @@ std::string cmLocalGenerator::GetIncludeFlags(
{
includeFlags << fwSearchFlag;
}
includeFlags << this->Convert(frameworkDir, START_OUTPUT,
shellFormat, true)
includeFlags << this->ConvertToOutputFormat(frameworkDir, shellFormat)
<< " ";
}
continue;
@ -2674,14 +2670,6 @@ cmLocalGenerator::ConstructComment(cmCustomCommandGenerator const& ccg,
return default_comment;
}
//----------------------------------------------------------------------------
std::string
cmLocalGenerator::ConvertToOptionallyRelativeOutputPath(
const std::string& remote)
{
return this->Convert(remote, START_OUTPUT, SHELL, true);
}
//----------------------------------------------------------------------------
const char* cmLocalGenerator::GetRelativeRootPath(RelativeRoot relroot)
{
@ -2699,42 +2687,39 @@ const char* cmLocalGenerator::GetRelativeRootPath(RelativeRoot relroot)
//----------------------------------------------------------------------------
std::string cmLocalGenerator::Convert(const std::string& source,
RelativeRoot relative,
OutputFormat output,
bool optional)
OutputFormat output)
{
// Convert the path to a relative path.
std::string result = source;
if (!optional || this->UseRelativePaths)
switch (relative)
{
switch (relative)
{
case HOME:
//result = cmSystemTools::CollapseFullPath(result.c_str());
result = this->ConvertToRelativePath(
this->GetState()->GetSourceDirectoryComponents(), result);
break;
case START:
//result = cmSystemTools::CollapseFullPath(result.c_str());
result = this->ConvertToRelativePath(
this->StateSnapshot.GetCurrentSourceDirectoryComponents(), result);
break;
case HOME_OUTPUT:
//result = cmSystemTools::CollapseFullPath(result.c_str());
result = this->ConvertToRelativePath(
this->GetState()->GetBinaryDirectoryComponents(), result);
break;
case START_OUTPUT:
//result = cmSystemTools::CollapseFullPath(result.c_str());
result = this->ConvertToRelativePath(
this->StateSnapshot.GetCurrentBinaryDirectoryComponents(), result);
break;
case FULL:
result = cmSystemTools::CollapseFullPath(result);
break;
case NONE:
break;
}
case HOME:
//result = cmSystemTools::CollapseFullPath(result.c_str());
result = this->ConvertToRelativePath(
this->GetState()->GetSourceDirectoryComponents(), result);
break;
case START:
//result = cmSystemTools::CollapseFullPath(result.c_str());
result = this->ConvertToRelativePath(
this->StateSnapshot.GetCurrentSourceDirectoryComponents(), result);
break;
case HOME_OUTPUT:
//result = cmSystemTools::CollapseFullPath(result.c_str());
result = this->ConvertToRelativePath(
this->GetState()->GetBinaryDirectoryComponents(), result);
break;
case START_OUTPUT:
//result = cmSystemTools::CollapseFullPath(result.c_str());
result = this->ConvertToRelativePath(
this->StateSnapshot.GetCurrentBinaryDirectoryComponents(), result);
break;
case FULL:
result = cmSystemTools::CollapseFullPath(result);
break;
case NONE:
break;
}
return this->ConvertToOutputFormat(result, output);
}
@ -2778,15 +2763,14 @@ std::string cmLocalGenerator::ConvertToOutputFormat(const std::string& source,
//----------------------------------------------------------------------------
std::string cmLocalGenerator::Convert(RelativeRoot remote,
const std::string& local,
OutputFormat output,
bool optional)
OutputFormat output, bool optional)
{
const char* remotePath = this->GetRelativeRootPath(remote);
// The relative root must have a path (i.e. not FULL or NONE)
assert(remotePath != 0);
if(!local.empty() && (!optional || this->UseRelativePaths))
if(!local.empty() && !optional)
{
std::vector<std::string> components;
cmSystemTools::SplitPath(local, components);

12
Source/cmLocalGenerator.h
View File

@ -115,8 +115,7 @@ public:
std::string ConvertToOutputFormat(const std::string& source,
OutputFormat output);
std::string Convert(const std::string& remote, RelativeRoot local,
OutputFormat output = UNCHANGED,
bool optional = false);
OutputFormat output = UNCHANGED);
std::string Convert(RelativeRoot remote, const std::string& local,
OutputFormat output = UNCHANGED,
bool optional = false);
@ -126,14 +125,6 @@ public:
*/
const char* GetRelativeRootPath(RelativeRoot relroot);
/**
* Convert the given path to an output path that is optionally
* relative based on the cache option CMAKE_USE_RELATIVE_PATHS. The
* remote path must use forward slashes and not already be escaped
* or quoted.
*/
std::string ConvertToOptionallyRelativeOutputPath(const std::string& remote);
///! set/get the parent generator
cmLocalGenerator* GetParent() const {return this->Parent;}
@ -460,7 +451,6 @@ protected:
std::set<cmTarget const*> WarnCMP0063;
bool LinkScriptShell;
bool UseRelativePaths;
bool Configured;
bool EmitUniversalBinaryFlags;

79
Source/cmLocalVisualStudio6Generator.cxx
View File

@ -235,13 +235,10 @@ void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmTarget& tgt)
comment += makefileIn;
std::string args;
args = "-H";
args += this->Convert(this->Makefile->GetHomeDirectory(),
START_OUTPUT, UNCHANGED, true);
args += this->Makefile->GetHomeDirectory();
commandLine.push_back(args);
args = "-B";
args +=
this->Convert(this->Makefile->GetHomeOutputDirectory(),
START_OUTPUT, UNCHANGED, true);
args += this->Makefile->GetHomeOutputDirectory();
commandLine.push_back(args);
std::vector<std::string> const& listFiles = this->Makefile->GetListFiles();
@ -498,7 +495,7 @@ void cmLocalVisualStudio6Generator
// Tell MS-Dev what the source is. If the compiler knows how to
// build it, then it will.
fout << "SOURCE=" <<
this->ConvertToOptionallyRelativeOutputPath(source.c_str()) << "\n\n";
this->ConvertToOutputFormat(source.c_str(), SHELL) << "\n\n";
if(!depends.empty())
{
// Write out the dependencies for the rule.
@ -507,7 +504,7 @@ void cmLocalVisualStudio6Generator
d != depends.end(); ++d)
{
fout << "\\\n\t" <<
this->ConvertToOptionallyRelativeOutputPath(d->c_str());
this->ConvertToOutputFormat(d->c_str(), SHELL);
}
fout << "\n";
}
@ -663,7 +660,7 @@ cmLocalVisualStudio6Generator
if(this->GetRealDependency(d->c_str(), config.c_str(), dep))
{
fout << "\\\n\t" <<
this->ConvertToOptionallyRelativeOutputPath(dep.c_str());
this->ConvertToOutputFormat(dep.c_str(), SHELL);
}
}
fout << "\n";
@ -689,7 +686,7 @@ cmLocalVisualStudio6Generator
++o)
{
// Write a rule for every output generated by this command.
fout << this->ConvertToOptionallyRelativeOutputPath(o->c_str())
fout << this->ConvertToOutputFormat(o->c_str(), SHELL)
<< " : \"$(SOURCE)\" \"$(INTDIR)\" \"$(OUTDIR)\"\n\t";
fout << script.c_str() << "\n\n";
}
@ -906,7 +903,7 @@ cmLocalVisualStudio6Generator::GetTargetIncludeOptions(cmTarget &target,
for(i = includes.begin(); i != includes.end(); ++i)
{
std::string tmp =
this->ConvertToOptionallyRelativeOutputPath(i->c_str());
this->ConvertToOutputFormat(i->c_str(), SHELL);
if(useShortPath)
{
cmSystemTools::GetShortPath(tmp.c_str(), tmp);
@ -997,14 +994,14 @@ void cmLocalVisualStudio6Generator
if(libPath.size())
{
std::string lpath =
this->ConvertToOptionallyRelativeOutputPath(libPath.c_str());
this->ConvertToOutputFormat(libPath.c_str(), SHELL);
if(lpath.size() == 0)
{
lpath = ".";
}
std::string lpathIntDir = libPath + "$(INTDIR)";
lpathIntDir =
this->ConvertToOptionallyRelativeOutputPath(lpathIntDir.c_str());
this->ConvertToOutputFormat(lpathIntDir.c_str(), SHELL);
if(pathEmitted.insert(lpath).second)
{
libOptions += " /LIBPATH:";
@ -1030,14 +1027,14 @@ void cmLocalVisualStudio6Generator
if(exePath.size())
{
std::string lpath =
this->ConvertToOptionallyRelativeOutputPath(exePath.c_str());
this->ConvertToOutputFormat(exePath.c_str(), SHELL);
if(lpath.size() == 0)
{
lpath = ".";
}
std::string lpathIntDir = exePath + "$(INTDIR)";
lpathIntDir =
this->ConvertToOptionallyRelativeOutputPath(lpathIntDir.c_str());
this->ConvertToOutputFormat(lpathIntDir.c_str(), SHELL);
if(pathEmitted.insert(lpath).second)
{
@ -1071,14 +1068,14 @@ void cmLocalVisualStudio6Generator
path += "/";
}
std::string lpath =
this->ConvertToOptionallyRelativeOutputPath(path.c_str());
this->ConvertToOutputFormat(path.c_str(), SHELL);
if(lpath.size() == 0)
{
lpath = ".";
}
std::string lpathIntDir = path + "$(INTDIR)";
lpathIntDir =
this->ConvertToOptionallyRelativeOutputPath(lpathIntDir.c_str());
this->ConvertToOutputFormat(lpathIntDir.c_str(), SHELL);
if(pathEmitted.insert(lpath).second)
{
libOptions += " /LIBPATH:";
@ -1142,9 +1139,9 @@ void cmLocalVisualStudio6Generator
libDebug += ".lib";
}
}
lib = this->ConvertToOptionallyRelativeOutputPath(lib.c_str());
lib = this->ConvertToOutputFormat(lib.c_str(), SHELL);
libDebug =
this->ConvertToOptionallyRelativeOutputPath(libDebug.c_str());
this->ConvertToOutputFormat(libDebug.c_str(), SHELL);
if (j->second == cmTarget::GENERAL)
{
@ -1367,21 +1364,21 @@ void cmLocalVisualStudio6Generator
{
#ifdef CM_USE_OLD_VS6
outputDirOld =
removeQuotes(this->ConvertToOptionallyRelativeOutputPath
(target.GetDirectory().c_str()));
removeQuotes(this->ConvertToOutputFormat
(target.GetDirectory().c_str(), SHELL));
#endif
outputDirDebug =
removeQuotes(this->ConvertToOptionallyRelativeOutputPath(
target.GetDirectory("Debug").c_str()));
removeQuotes(this->ConvertToOutputFormat(
target.GetDirectory("Debug").c_str(), SHELL));
outputDirRelease =
removeQuotes(this->ConvertToOptionallyRelativeOutputPath(
target.GetDirectory("Release").c_str()));
removeQuotes(this->ConvertToOutputFormat(
target.GetDirectory("Release").c_str(), SHELL));
outputDirMinSizeRel =
removeQuotes(this->ConvertToOptionallyRelativeOutputPath(
target.GetDirectory("MinSizeRel").c_str()));
removeQuotes(this->ConvertToOutputFormat(
target.GetDirectory("MinSizeRel").c_str(), SHELL));
outputDirRelWithDebInfo =
removeQuotes(this->ConvertToOptionallyRelativeOutputPath(
target.GetDirectory("RelWithDebInfo").c_str()));
removeQuotes(this->ConvertToOutputFormat(
target.GetDirectory("RelWithDebInfo").c_str(), SHELL));
}
else if(target.GetType() == cmTarget::OBJECT_LIBRARY)
{
@ -1449,15 +1446,13 @@ void cmLocalVisualStudio6Generator
targetImplibFlagMinSizeRel = "/implib:";
targetImplibFlagRelWithDebInfo = "/implib:";
targetImplibFlagDebug +=
this->ConvertToOptionallyRelativeOutputPath(fullPathImpDebug.c_str());
this->ConvertToOutputFormat(fullPathImpDebug.c_str(), SHELL);
targetImplibFlagRelease +=
this->ConvertToOptionallyRelativeOutputPath(fullPathImpRelease.c_str());
this->ConvertToOutputFormat(fullPathImpRelease.c_str(), SHELL);
targetImplibFlagMinSizeRel +=
this->ConvertToOptionallyRelativeOutputPath(
fullPathImpMinSizeRel.c_str());
this->ConvertToOutputFormat(fullPathImpMinSizeRel.c_str(), SHELL);
targetImplibFlagRelWithDebInfo +=
this->ConvertToOptionallyRelativeOutputPath(
fullPathImpRelWithDebInfo.c_str());
this->ConvertToOutputFormat(fullPathImpRelWithDebInfo.c_str(), SHELL);
}
#ifdef CM_USE_OLD_VS6
@ -1669,12 +1664,12 @@ void cmLocalVisualStudio6Generator
// to convert to output path for unix to win32 conversion
cmSystemTools::ReplaceString
(line, "LIBRARY_OUTPUT_PATH",
removeQuotes(this->ConvertToOptionallyRelativeOutputPath
(libPath.c_str())).c_str());
removeQuotes(this->ConvertToOutputFormat
(libPath.c_str(), SHELL)).c_str());
cmSystemTools::ReplaceString
(line, "EXECUTABLE_OUTPUT_PATH",
removeQuotes(this->ConvertToOptionallyRelativeOutputPath
(exePath.c_str())).c_str());
removeQuotes(this->ConvertToOutputFormat
(exePath.c_str(), SHELL)).c_str());
#endif
if(targetBuilds || target.GetType() == cmTarget::OBJECT_LIBRARY)
@ -1884,9 +1879,9 @@ void cmLocalVisualStudio6Generator
}
dir += "$(IntDir)";
options += "# ADD LINK32 /LIBPATH:";
options += this->ConvertToOptionallyRelativeOutputPath(dir.c_str());
options += this->ConvertToOutputFormat(dir.c_str(), SHELL);
options += " /LIBPATH:";
options += this->ConvertToOptionallyRelativeOutputPath(d->c_str());
options += this->ConvertToOutputFormat(d->c_str(), SHELL);
options += "\n";
}
}
@ -1897,7 +1892,7 @@ void cmLocalVisualStudio6Generator
if(l->IsPath)
{
options +=
this->ConvertToOptionallyRelativeOutputPath(l->Value.c_str());
this->ConvertToOutputFormat(l->Value.c_str(), SHELL);
}
else if (!l->Target
|| l->Target->GetType() != cmTarget::INTERFACE_LIBRARY)
@ -1933,7 +1928,7 @@ void cmLocalVisualStudio6Generator
options += "# ADD ";
options += tool;
options += "32 ";
options += this->ConvertToOptionallyRelativeOutputPath(oi->c_str());
options += this->ConvertToOutputFormat(oi->c_str(), SHELL);
options += "\n";
}
}

13
Source/cmLocalVisualStudio7Generator.cxx
View File

@ -299,13 +299,10 @@ cmSourceFile* cmLocalVisualStudio7Generator::CreateVCProjBuildRule()
comment += makefileIn;
std::string args;
args = "-H";
args += this->Convert(this->Makefile->GetHomeDirectory(),
START_OUTPUT, UNCHANGED, true);
args += this->Makefile->GetHomeDirectory();
commandLine.push_back(args);
args = "-B";
args +=
this->Convert(this->Makefile->GetHomeOutputDirectory(),
START_OUTPUT, UNCHANGED, true);
args += this->Makefile->GetHomeOutputDirectory();
commandLine.push_back(args);
commandLine.push_back("--check-stamp-file");
std::string stampFilename = this->Convert(stampName.c_str(), FULL,
@ -1081,7 +1078,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
if(!this->ModuleDefinitionFile.empty())
{
std::string defFile =
this->ConvertToOptionallyRelativeOutputPath(this->ModuleDefinitionFile);
this->ConvertToOutputFormat(this->ModuleDefinitionFile, SHELL);
linkOptions.AddFlag("ModuleDefinitionFile", defFile.c_str());
}
switch(target.GetType())
@ -2228,7 +2225,7 @@ std::string cmLocalVisualStudio7Generator::EscapeForXML(const std::string& s)
std::string cmLocalVisualStudio7Generator
::ConvertToXMLOutputPath(const char* path)
{
std::string ret = this->ConvertToOptionallyRelativeOutputPath(path);
std::string ret = this->ConvertToOutputFormat(path, SHELL);
cmSystemTools::ReplaceString(ret, "&", "&amp;");
cmSystemTools::ReplaceString(ret, "\"", "&quot;");
cmSystemTools::ReplaceString(ret, "<", "&lt;");
@ -2239,7 +2236,7 @@ std::string cmLocalVisualStudio7Generator
std::string cmLocalVisualStudio7Generator
::ConvertToXMLOutputPathSingle(const char* path)
{
std::string ret = this->ConvertToOptionallyRelativeOutputPath(path);
std::string ret = this->ConvertToOutputFormat(path, SHELL);
cmSystemTools::ReplaceString(ret, "\"", "");
cmSystemTools::ReplaceString(ret, "&", "&amp;");
cmSystemTools::ReplaceString(ret, "<", "&lt;");

13
Source/cmMakefileTargetGenerator.cxx
View File

@ -614,13 +614,7 @@ cmMakefileTargetGenerator
}
// Get the output paths for source and object files.
std::string sourceFile = source.GetFullPath();
if(this->LocalGenerator->UseRelativePaths)
{
sourceFile = this->Convert(sourceFile,
cmLocalGenerator::START_OUTPUT);
}
sourceFile = this->Convert(sourceFile,
std::string sourceFile = this->Convert(source.GetFullPath(),
cmLocalGenerator::NONE,
cmLocalGenerator::SHELL);
@ -1595,9 +1589,8 @@ std::string cmMakefileTargetGenerator::GetFrameworkFlags(std::string const& l)
if(emitted.insert(*i).second)
{
flags += fwSearchFlag;
flags += this->Convert(*i,
cmLocalGenerator::START_OUTPUT,
cmLocalGenerator::SHELL, true);
flags += this->LocalGenerator
->ConvertToOutputFormat(*i, cmLocalGenerator::SHELL);
flags += " ";
}
}

5
Source/cmMakefileTargetGenerator.h
View File

@ -273,10 +273,9 @@ protected:
std::string Convert(const std::string& source,
cmLocalGenerator::RelativeRoot relative,
cmLocalGenerator::OutputFormat output =
cmLocalGenerator::UNCHANGED,
bool optional = false)
cmLocalGenerator::UNCHANGED)
{
return this->LocalGenerator->Convert(source, relative, output, optional);
return this->LocalGenerator->Convert(source, relative, output);
}
};

5
Source/cmVisualStudio10TargetGenerator.cxx
View File

@ -922,10 +922,7 @@ cmVisualStudio10TargetGenerator::ConvertPath(std::string const& path,
return forceRelative
? cmSystemTools::RelativePath(
this->Makefile->GetCurrentBinaryDirectory(), path.c_str())
: this->LocalGenerator->Convert(path.c_str(),
cmLocalGenerator::START_OUTPUT,
cmLocalGenerator::UNCHANGED,
/* optional = */ true);
: path.c_str();
}
void cmVisualStudio10TargetGenerator::ConvertToWindowsSlash(std::string& s)

14
Source/cmake.cxx
View File

@ -1437,20 +1437,6 @@ int cmake::ActualConfigure()
cmState::PATH);
}
}
if(!this->State
->GetInitializedCacheValue("CMAKE_USE_RELATIVE_PATHS"))
{
this->State->AddCacheEntry
("CMAKE_USE_RELATIVE_PATHS", "OFF",
"If true, cmake will use relative paths in makefiles and projects.",
cmState::BOOL);
if (!this->State->GetCacheEntryProperty("CMAKE_USE_RELATIVE_PATHS",
"ADVANCED"))
{
this->State->SetCacheEntryProperty("CMAKE_USE_RELATIVE_PATHS",
"ADVANCED", "1");
}
}
if(cmSystemTools::GetFatalErrorOccured())
{