Attached Files | cmGlobalXCodeGenerator_cxx.txt [^] (23,950 bytes) 2012-02-07 17:28 [Show Content] [Hide Content]mpechner-mbp:Source michael.pechner$ diff cmGlobalXCodeGenerator.cxx ~/Desktop/cmake-2.8.7/Source/cmGlobalXCodeGenerator.cxx
150c150
< std::cerr << "CMake should be built with cmake to use XCode, "
---
> std::cerr << "CMake should be built with cmake to use Xcode, "
168,174c168,177
< mf->AddCacheDefinition(
< "CMAKE_CONFIGURATION_TYPES",
< "Debug;Release;MinSizeRel;RelWithDebInfo",
< "Semicolon separated list of supported configuration types, "
< "only supports Debug, Release, MinSizeRel, and RelWithDebInfo, "
< "anything else will be ignored.",
< cmCacheManager::STRING);
---
> if(!mf->GetDefinition("CMAKE_CONFIGURATION_TYPES"))
> {
> mf->AddCacheDefinition(
> "CMAKE_CONFIGURATION_TYPES",
> "Debug;Release;MinSizeRel;RelWithDebInfo",
> "Semicolon separated list of supported configuration types, "
> "only supports Debug, Release, MinSizeRel, and RelWithDebInfo, "
> "anything else will be ignored.",
> cmCacheManager::STRING);
> }
322a326,343
> std::string
> cmGlobalXCodeGenerator::PostBuildMakeTarget(std::string const& tName,
> std::string const& configName)
> {
> std::string target = tName;
> cmSystemTools::ReplaceString(target, " ", "_");
> std::string out = "PostBuild." + target;
> if(this->XcodeVersion > 20)
> {
> out += "." + configName;
> }
> return out;
> }
>
> //----------------------------------------------------------------------------
> #define CMAKE_CHECK_BUILD_SYSTEM_TARGET "ZERO_CHECK"
>
> //----------------------------------------------------------------------------
351,353c372,384
< if(this->XcodeVersion > 20)
< {
< makecommand.push_back("all.$(CONFIGURATION)");
---
> makecommand.push_back(""); // placeholder, see below
>
> // Add ZERO_CHECK
> bool regenerate = !mf->IsOn("CMAKE_SUPPRESS_REGENERATION");
> if (regenerate)
> {
> this->CreateReRunCMakeFile(root, gens);
> std::string file = this->ConvertToRelativeForMake(
> this->CurrentReRunCMakeMakefile.c_str());
> cmSystemTools::ReplaceString(file, "\\ ", " ");
> mf->AddUtilityCommand(CMAKE_CHECK_BUILD_SYSTEM_TARGET, true, no_depends,
> no_working_directory,
> "make", "-f", file.c_str());
355,358d385
< cmCustomCommandLines commandLines;
< commandLines.push_back(makecommand);
< // Add Re-Run CMake rules
< this->CreateReRunCMakeFile(root, gens);
369a397
>
373a402,407
>
> if (regenerate && (l->first != CMAKE_CHECK_BUILD_SYSTEM_TARGET))
> {
> target.AddUtility(CMAKE_CHECK_BUILD_SYSTEM_TARGET);
> }
>
382a417,420
> makecommand[makecommand.size()-1] =
> this->PostBuildMakeTarget(target.GetName(), "$(CONFIGURATION)");
> cmCustomCommandLines commandLines;
> commandLines.push_back(makecommand);
389d426
<
390a428
>
423,424c461
< std::string dir = mf->GetHomeOutputDirectory();
< this->CurrentReRunCMakeMakefile = dir;
---
> this->CurrentReRunCMakeMakefile = mf->GetStartOutputDirectory();
455a493
> this->XCodeObjectIDs.clear();
462a501,521
> void cmGlobalXCodeGenerator::addObject(cmXCodeObject *obj)
> {
> if(obj->GetType() == cmXCodeObject::OBJECT)
> {
> cmStdString id = obj->GetId();
>
> // If this is a duplicate id, it's an error:
> //
> if(this->XCodeObjectIDs.count(id))
> {
> cmSystemTools::Error(
> "Xcode generator: duplicate object ids not allowed");
> }
>
> this->XCodeObjectIDs.insert(id);
> }
>
> this->XCodeObjects.push_back(obj);
> }
>
> //----------------------------------------------------------------------------
475c534
< this->XCodeObjects.push_back(obj);
---
> this->addObject(obj);
484c543
< this->XCodeObjects.push_back(obj);
---
> this->addObject(obj);
526a586,592
> const char* srcfmt = sf->GetProperty("Fortran_FORMAT");
> switch(this->CurrentLocalGenerator->GetFortranFormat(srcfmt))
> {
> case cmLocalGenerator::FortranFormatFixed: flags="-fixed "+flags; break;
> case cmLocalGenerator::FortranFormatFree: flags="-free "+flags; break;
> default: break;
> }
580a647,652
> if(cmtarget.IsCFBundleOnApple())
> {
> cmtarget.SetProperty("PREFIX", "");
> cmtarget.SetProperty("SUFFIX", "");
> }
>
671,674d742
< else if(lang && strcmp(lang, "ASM") == 0)
< {
< sourcecode += ".asm";
< }
713c781,782
< tname == "install" || tname == "package" || tname == "RUN_TESTS" )
---
> tname == "install" || tname == "package" || tname == "RUN_TESTS" ||
> tname == CMAKE_CHECK_BUILD_SYSTEM_TARGET )
818a888
> bool isCFBundleTarget = cmtarget.IsCFBundleOnApple();
864c934,935
< if (!resourceFiles.empty() && (isFrameworkTarget || isBundleTarget))
---
> if (!resourceFiles.empty() &&
> (isFrameworkTarget || isBundleTarget || isCFBundleTarget))
885c956
< if (isFrameworkTarget || isBundleTarget)
---
> if (isFrameworkTarget || isBundleTarget || isCFBundleTarget)
959c1030
< // create list of build phases and create the XCode target
---
> // create list of build phases and create the Xcode target
1097,1101d1167
< std::vector<cmCustomCommand> reruncom;
< cmXCodeObject* cmakeReRunPhase =
< this->CreateBuildPhase("CMake ReRun", "cmakeReRunPhase",
< cmtarget, reruncom);
< buildPhases->AddObject(cmakeReRunPhase);
1164a1231,1232
> // This function removes each occurence of the flag and returns the last one
> // (i.e., the dominant flag in GCC)
1169,1170c1237,1239
< std::string::size_type pos = flags.find(flag);
< if(pos != flags.npos && (pos ==0 || flags[pos-1]==' '))
---
> std::string::size_type pos = flags.rfind(flag);
> bool saved = false;
> while(pos != flags.npos)
1172c1241
< while(pos < flags.size() && flags[pos] != ' ')
---
> if(pos == 0 || flags[pos-1]==' ')
1174,1176c1243,1251
< retFlag += flags[pos];
< flags[pos] = ' ';
< pos++;
---
> while(pos < flags.size() && flags[pos] != ' ')
> {
> if(!saved)
> {
> retFlag += flags[pos];
> }
> flags[pos] = ' ';
> pos++;
> }
1177a1253,1254
> saved = true;
> pos = flags.rfind(flag);
1190,1203d1266
< if(strcmp(name, "cmakeReRunPhase") == 0)
< {
< std::string cdir = this->CurrentMakefile->GetHomeOutputDirectory();
< cdir = this->ConvertToRelativeForMake(cdir.c_str());
< std::string makecmd = "make -C ";
< makecmd += cdir;
< makecmd += " -f ";
< makecmd +=
< this->ConvertToRelativeForMake(this->CurrentReRunCMakeMakefile.c_str());
< cmSystemTools::ReplaceString(makecmd, "\\ ", "\\\\ ");
< buildphase->AddAttribute("shellScript",
< this->CreateString(makecmd.c_str()));
< return;
< }
1266a1330,1331
> buildphase->AddAttribute("showEnvVarsInLog",
> this->CreateString("0"));
1463c1528,1529
< this->AppendDefines(ppDefs, "CMAKE_INTDIR=\"$(CONFIGURATION)\"");
---
> this->AppendDefines(ppDefs,
> "CMAKE_INTDIR=\"$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)\"");
1580,1582c1646,1651
< std::string pncdir = target.GetDirectory(configName);
< buildSettings->AddAttribute("CONFIGURATION_BUILD_DIR",
< this->CreateString(pncdir.c_str()));
---
> if(!target.UsesDefaultOutputDir(configName, false))
> {
> std::string pncdir = target.GetDirectory(configName);
> buildSettings->AddAttribute("CONFIGURATION_BUILD_DIR",
> this->CreateString(pncdir.c_str()));
> }
1612c1681,1707
< if(this->XcodeVersion >= 22)
---
> if (target.GetPropertyAsBool("BUNDLE"))
> {
> // It turns out that a BUNDLE is basically the same
> // in many ways as an application bundle, as far as
> // link flags go
> std::string createFlags =
> this->LookupFlags("CMAKE_SHARED_MODULE_CREATE_", lang, "_FLAGS",
> "-bundle");
> if(!createFlags.empty())
> {
> extraLinkOptions += " ";
> extraLinkOptions += createFlags;
> }
> std::string plist = this->ComputeInfoPListLocation(target);
> // Xcode will create the final version of Info.plist at build time,
> // so let it replace the cfbundle name. This avoids creating
> // a per-configuration Info.plist file. The cfbundle plist
> // is very similar to the application bundle plist
> this->CurrentLocalGenerator
> ->GenerateAppleInfoPList(&target, "$(EXECUTABLE_NAME)",
> plist.c_str());
> std::string path =
> this->ConvertToRelativeForXCode(plist.c_str());
> buildSettings->AddAttribute("INFOPLIST_FILE",
> this->CreateString(path.c_str()));
> }
> else if(this->XcodeVersion >= 22)
1651c1746
< // so let it replace the framework name. This avoids creating
---
> // so let it replace the framework name. This avoids creating
1710c1805
< if(this->XcodeVersion >= 22)
---
> if(this->XcodeVersion >= 22 && this->XcodeVersion < 40)
1800c1895,1905
< if(gflagc.size() ==0 && gflag.size() == 0)
---
> // We can't set the Xcode flag differently depending on the language,
> // so put them back in this case.
> if( (lang && strcmp(lang, "CXX") == 0) && gflag != gflagc )
> {
> cflags += " ";
> cflags += gflagc;
> flags += " ";
> flags += gflag;
> debugStr = "NO";
> }
> if( gflag == "-g0" || gflag.size() == 0 )
1832a1938,1952
> // Add Fortran source format attribute if property is set.
> const char* format = 0;
> const char* tgtfmt = target.GetProperty("Fortran_FORMAT");
> switch(this->CurrentLocalGenerator->GetFortranFormat(tgtfmt))
> {
> case cmLocalGenerator::FortranFormatFixed: format = "fixed"; break;
> case cmLocalGenerator::FortranFormatFree: format = "free"; break;
> default: break;
> }
> if(format)
> {
> buildSettings->AddAttribute("IFORT_LANG_SRCFMT",
> this->CreateString(format));
> }
>
1852,1855d1971
< // -- move this line from below, on all targets, to here where it ONLY sets INSTALL_PATH in this case,
< // which fixes a problem where XCode 4 won't "ARCHIVE" unless the component targets have an unset INSTALL_PATH
< buildSettings->AddAttribute("INSTALL_PATH",
< this->CreateString(install_name_dir.c_str()));
1857a1974,1975
> buildSettings->AddAttribute("INSTALL_PATH",
> this->CreateString(install_name_dir.c_str()));
1950a2069,2071
> shellBuildPhase->AddAttribute("showEnvVarsInLog",
> this->CreateString("0"));
>
1993a2115,2117
> target->SetId(this->GetOrCreateId(
> cmtarget.GetName(), target->GetId()).c_str());
>
2052c2176,2179
< return ((this->XcodeVersion >= 22)?
---
> if (cmtarget.IsCFBundleOnApple())
> return "wrapper.plug-in";
> else
> return ((this->XcodeVersion >= 22)?
2067,2072d2193
< // When producing certain types of bundles (front row appliances), they should also
< // have a particular product type.
< const char* productType = cmtarget.GetProperty("MACOSX_PRODUCT_TYPE");
< if (productType)
< return productType;
<
2078,2079c2199,2204
< return ((this->XcodeVersion >= 22)? "com.apple.product-type.tool" :
< "com.apple.product-type.library.dynamic");
---
> if (cmtarget.IsCFBundleOnApple())
> return "com.apple.product-type.bundle";
> else
> return ((this->XcodeVersion >= 22)?
> "com.apple.product-type.tool" :
> "com.apple.product-type.library.dynamic");
2140a2266,2267
> target->SetId(this->GetOrCreateId(
> cmtarget.GetName(), target->GetId()).c_str());
2163a2291,2310
> std::string cmGlobalXCodeGenerator::GetOrCreateId(const char* name,
> const char* id)
> {
> std::string guidStoreName = name;
> guidStoreName += "_GUID_CMAKE";
> const char* storedGUID =
> this->CMakeInstance->GetCacheDefinition(guidStoreName.c_str());
>
> if(storedGUID)
> {
> return storedGUID;
> }
>
> this->CMakeInstance->AddCacheEntry(guidStoreName.c_str(),
> id, "Stored Xcode object GUID", cmCacheManager::INTERNAL);
>
> return id;
> }
>
> //----------------------------------------------------------------------------
2357c2504,2505
< // now add the same one but append $(CONFIGURATION) to it:
---
> // Now add the same one but append
> // $(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME) to it:
2360c2508
< (*libDir + "/$(CONFIGURATION)").c_str());
---
> (*libDir + "/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)").c_str());
2407a2556,2559
> if(li->Target && !li->Target->IsImported())
> {
> target->AddDependTarget(configName, li->Target->GetName());
> }
2462c2614,2617
< sourceGroup.AssignSource( sf );
---
> cmXCodeObject* pbxgroup =
> this->CreateOrGetPBXGroup(cmtarget, &sourceGroup);
> cmStdString key = GetGroupMapKey(cmtarget, sf);
> this->GroupMap[key] = pbxgroup;
2464,2470c2619
< // Create all of the groups that should be created for this target.
< // Loop through every source group.
< for(unsigned int i = 0; i < sourceGroups.size(); ++i)
< {
< CreateSourceGroup( sourceGroups[i], cmtarget, false );
< }
< }
---
> }
2474,2475c2623,2624
< cmXCodeObject* cmGlobalXCodeGenerator
< ::CreateSourceGroup(cmSourceGroup& sg, cmTarget& cmtarget, bool child_group)
---
> cmXCodeObject *cmGlobalXCodeGenerator
> ::CreatePBXGroup(cmXCodeObject *parent, cmStdString name)
2477,2502c2626,2641
< // Only do something with the group if there are files or child groups
< if( !sg.GetSourceFiles().empty() || !sg.GetGroupChildren().empty() )
< {
< cmXCodeObject* pbxgroup = this->CreateOrGetPBXGroup(cmtarget, &sg, !child_group);
<
< std::vector<const cmSourceFile*>& sources = sg.GetSourceFiles();
< // Get all the source files and add them to the GroupMap
< for(std::vector<const cmSourceFile*>::const_iterator s = sources.begin();
< s != sources.end(); s++)
< {
< cmStdString key = GetGroupMapKey(cmtarget, (cmSourceFile*)*s);
< this->GroupMap[key] = pbxgroup;
< }
<
< // Do the child groups
< std::vector<cmSourceGroup> children = sg.GetGroupChildren();
< cmXCodeObject* groupChildren = pbxgroup->GetObject("children");
<
< for(unsigned int i=0;i<children.size();++i)
< {
< cmXCodeObject* group = this->CreateSourceGroup( children[i], cmtarget, true );
< groupChildren->AddObject(group);
< }
< return pbxgroup;
< }
< return NULL;
---
> cmXCodeObject* parentChildren = NULL;
> if(parent)
> parentChildren = parent->GetObject("children");
> cmXCodeObject* group = this->CreateObject(cmXCodeObject::PBXGroup);
> cmXCodeObject* groupChildren =
> this->CreateObject(cmXCodeObject::OBJECT_LIST);
> group->AddAttribute("name", this->CreateString(name.c_str()));
> group->AddAttribute("children", groupChildren);
> if(this->XcodeVersion == 15)
> {
> group->AddAttribute("refType", this->CreateString("4"));
> }
> group->AddAttribute("sourceTree", this->CreateString("<group>"));
> if(parentChildren)
> parentChildren->AddObject(group);
> return group;
2505,2506d2643
<
<
2509c2646
< ::CreateOrGetPBXGroup(cmTarget& cmtarget, cmSourceGroup* sg, bool target_child)
---
> ::CreateOrGetPBXGroup(cmTarget& cmtarget, cmSourceGroup* sg)
2511,2512c2648,2656
< cmStdString s = cmtarget.GetName();
< s += "/";
---
> cmStdString s;
> cmStdString target;
> const char *targetFolder= cmtarget.GetProperty("FOLDER");
> if(targetFolder) {
> target = targetFolder;
> target += "/";
> }
> target += cmtarget.GetName();
> s = target + "/";
2514c2658
< std::map<cmStdString, cmXCodeObject* >::iterator i =
---
> std::map<cmStdString, cmXCodeObject* >::iterator it =
2516c2660
< if(i != this->GroupNameMap.end())
---
> if(it != this->GroupNameMap.end())
2518c2662
< return i->second;
---
> return it->second;
2520c2664,2665
< i = this->TargetGroup.find(cmtarget.GetName());
---
>
> it = this->TargetGroup.find(target);
2522c2667
< if(i != this->TargetGroup.end())
---
> if(it != this->TargetGroup.end())
2524c2669
< tgroup = i->second;
---
> tgroup = it->second;
2528,2536c2673,2694
< tgroup = this->CreateObject(cmXCodeObject::PBXGroup);
< this->TargetGroup[cmtarget.GetName()] = tgroup;
< cmXCodeObject* tgroupChildren =
< this->CreateObject(cmXCodeObject::OBJECT_LIST);
< tgroup->AddAttribute("name", this->CreateString(cmtarget.GetName()));
< tgroup->AddAttribute("children", tgroupChildren);
< if(this->XcodeVersion == 15)
< {
< tgroup->AddAttribute("refType", this->CreateString("4"));
---
> std::vector<std::string> tgt_folders =
> cmSystemTools::tokenize(target, "/");
> cmStdString curr_tgt_folder;
> for(std::vector<std::string>::size_type i = 0; i < tgt_folders.size();i++)
> {
> curr_tgt_folder += tgt_folders[i];
> it = this->TargetGroup.find(curr_tgt_folder);
> if(it == this->TargetGroup.end())
> {
> tgroup = this->CreatePBXGroup(tgroup,tgt_folders[i]);
> this->TargetGroup[curr_tgt_folder] = tgroup;
> }
> else
> {
> tgroup = it->second;
> continue;
> }
> if(i == 0)
> {
> this->SourcesGroupChildren->AddObject(tgroup);
> }
> curr_tgt_folder += "/";
2538,2539d2695
< tgroup->AddAttribute("sourceTree", this->CreateString("<group>"));
< this->SourcesGroupChildren->AddObject(tgroup);
2540a2697
> this->TargetGroup[target] = tgroup;
2545c2702
< if (cmStdString(sg->GetName()) == "")
---
> if (cmStdString(sg->GetFullName()) == "")
2551,2556c2708,2709
< cmXCodeObject* group = this->CreateObject(cmXCodeObject::PBXGroup);
< cmXCodeObject* groupChildren =
< this->CreateObject(cmXCodeObject::OBJECT_LIST);
< group->AddAttribute("name", this->CreateString(sg->GetName()));
< group->AddAttribute("children", groupChildren);
< if(this->XcodeVersion == 15)
---
> //It's a recursive folder structure, let's find the real parent group
> if(std::string(sg->GetFullName()) != std::string(sg->GetName()))
2558,2564c2711,2733
< group->AddAttribute("refType", this->CreateString("4"));
< }
< group->AddAttribute("sourceTree", this->CreateString("<group>"));
< if( target_child )
< {
< cmXCodeObject* tgroupChildren = tgroup->GetObject("children");
< tgroupChildren->AddObject(group);
---
> std::vector<std::string> folders =
> cmSystemTools::tokenize(sg->GetFullName(), "\\");
> cmStdString curr_folder = cmtarget.GetName();
> curr_folder += "/";
> for(std::vector<std::string>::size_type i = 0; i < folders.size();i++)
> {
> curr_folder += folders[i];
> std::map<cmStdString, cmXCodeObject* >::iterator i_folder =
> this->GroupNameMap.find(curr_folder);
> //Create new folder
> if(i_folder == this->GroupNameMap.end())
> {
> cmXCodeObject *group = this->CreatePBXGroup(tgroup,folders[i]);
> this->GroupNameMap[curr_folder] = group;
> tgroup = group;
> }
> else
> {
> tgroup = i_folder->second;
> }
> curr_folder = curr_folder + "\\";
> }
> return tgroup;
2566c2735
<
---
> cmXCodeObject *group = this->CreatePBXGroup(tgroup,sg->GetName());
2669a2839,2844
>
> std::string project_id = "PROJECT_";
> project_id += root->GetMakefile()->GetProjectName();
> this->RootObject->SetId(this->GetOrCreateId(
> project_id.c_str(), this->RootObject->GetId()).c_str());
>
2893,2927c3068,3071
< makefileStream << "# up-to-date with anything they link to, avoiding a "
< "bug in XCode 1.5\n";
< for(std::vector<std::string>::const_iterator
< ct = this->CurrentConfigurationTypes.begin();
< ct != this->CurrentConfigurationTypes.end(); ++ct)
< {
< if(this->XcodeVersion < 21 || ct->empty())
< {
< makefileStream << "all: ";
< }
< else
< {
< makefileStream << "all." << *ct << ": ";
< }
< const char* configName = 0;
< if(!ct->empty())
< {
< configName = ct->c_str();
< }
< for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
< i != targets.end(); ++i)
< {
< cmXCodeObject* target = *i;
< cmTarget* t =target->GetTarget();
< if(t->GetType() == cmTarget::EXECUTABLE ||
< t->GetType() == cmTarget::SHARED_LIBRARY ||
< t->GetType() == cmTarget::MODULE_LIBRARY)
< {
< std::string tfull = t->GetFullPath(configName);
< makefileStream << "\\\n\t" <<
< this->ConvertToRelativeForMake(tfull.c_str());
< }
< }
< makefileStream << "\n\n";
< }
---
> makefileStream << "# up-to-date with anything they link to\n"
> "default:\n"
> "\techo \"Do not invoke directly\"\n"
> "\n";
2972a3117,3127
>
> if(t->GetType() == cmTarget::EXECUTABLE ||
> t->GetType() == cmTarget::STATIC_LIBRARY ||
> t->GetType() == cmTarget::SHARED_LIBRARY ||
> t->GetType() == cmTarget::MODULE_LIBRARY)
> {
> // Declare an entry point for the target post-build phase.
> makefileStream << this->PostBuildMakeTarget(t->GetName(), *ct)
> << ":\n";
> }
>
2977d3131
< // Create a rule for this target.
2979,2980c3133,3150
< makefileStream << this->ConvertToRelativeForMake(tfull.c_str())
< << ":";
---
> std::string trel = this->ConvertToRelativeForMake(tfull.c_str());
>
> // Add this target to the post-build phases of its dependencies.
> std::map<cmStdString, cmXCodeObject::StringVec>::const_iterator
> y = target->GetDependTargets().find(*ct);
> if(y != target->GetDependTargets().end())
> {
> std::vector<cmStdString> const& deptgts = y->second;
> for(std::vector<cmStdString>::const_iterator d = deptgts.begin();
> d != deptgts.end(); ++d)
> {
> makefileStream << this->PostBuildMakeTarget(*d, *ct) << ": "
> << trel << "\n";
> }
> }
>
> // Create a rule for this target.
> makefileStream << trel << ":";
3072a3243,3247
>
> // Since this call may have created new cache entries, save the cache:
> //
> root->GetMakefile()->GetCacheManager()->SaveCache(
> root->GetMakefile()->GetHomeOutputDirectory());
3115c3290,3291
< return this->XcodeVersion >= 21? "$(CONFIGURATION)" : ".";
---
> return this->XcodeVersion >= 21 ?
> "$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)" : ".";
3123c3299
< entry.Brief = "Generate XCode project files.";
---
> entry.Brief = "Generate Xcode project files.";
3344c3520,3527
< flags += "\\\\'";
---
> if (this->XcodeVersion >= 40)
> {
> flags += "'\\\\''";
> }
> else
> {
> flags += "\\\\'";
> }
mpechner-mbp:Source michael.pechner$ diff cmGlobalXCodeGenerator.cxx ~/Desktop/cmake-2.8.7/Source/cmGlobalXCodeGenerator.
cmGlobalXCodeGenerator.cxx cmGlobalXCodeGenerator.h
mpechner-mbp:Source michael.pechner$ diff cmGlobalXCodeGenerator.cxx ~/Desktop/cmake-2.8.7/Source/cmGlobalXCodeGenerator.
0001-Fixed-nested-source-group-handling-in-Xcode-generato.patch [^] (907 bytes) 2012-09-28 16:06 [Show Content] [Hide Content]From 6bc39b8155be0cd138875e83bfa4755efd429e4f Mon Sep 17 00:00:00 2001
From: Mad Fish <MadFishTheOne@gmail.com>
Date: Fri, 28 Sep 2012 22:03:53 +0200
Subject: [PATCH] Fixed nested source group handling in Xcode generator.
---
Source/cmGlobalXCodeGenerator.cxx | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx
index 39b0ffe..0c01c44 100644
--- a/Source/cmGlobalXCodeGenerator.cxx
+++ b/Source/cmGlobalXCodeGenerator.cxx
@@ -2883,7 +2883,7 @@ cmXCodeObject* cmGlobalXCodeGenerator
{
std::vector<std::string> folders =
cmSystemTools::tokenize(sg->GetFullName(), "\\");
- cmStdString curr_folder = cmtarget.GetName();
+ cmStdString curr_folder = target;
curr_folder += "/";
for(std::vector<std::string>::size_type i = 0; i < folders.size();i++)
{
--
1.7.9.6 (Apple Git-31.1)
|