Commit 8e4c7b99 authored by David Cole's avatar David Cole
Browse files

ENH: Finish up the Framework creation code restructuring. Frameworks build and...

ENH: Finish up the Framework creation code restructuring. Frameworks build and install now. More work needed on the packaging step. See Tests/Framework for example use.
parent aa9ba5c3
......@@ -1277,6 +1277,7 @@ cmLocalGenerator* cmGlobalGenerator::FindLocalGenerator(const char* start_dir)
}
//----------------------------------------------------------------------------
cmTarget* cmGlobalGenerator::FindTarget(const char* project,
const char* name,
bool useImportedTargets)
......@@ -1318,6 +1319,27 @@ cmTarget* cmGlobalGenerator::FindTarget(const char* project,
return 0;
}
//----------------------------------------------------------------------------
bool cmGlobalGenerator::NameResolvesToFramework(const std::string& libname)
{
if(cmSystemTools::IsPathToFramework(libname.c_str()))
{
return true;
}
if(cmTarget* tgt = this->FindTarget(0, libname.c_str(), true))
{
if(tgt->GetType() == cmTarget::SHARED_LIBRARY &&
tgt->GetPropertyAsBool("FRAMEWORK"))
{
return true;
}
}
return false;
}
//----------------------------------------------------------------------------
inline std::string removeQuotes(const std::string& s)
{
if(s[0] == '\"' && s[s.size()-1] == '\"')
......
......@@ -187,6 +187,10 @@ public:
const char* name,
bool useImportedTargets);
/** Determine if a name resolves to a framework on disk or a built target
that is a framework. */
bool NameResolvesToFramework(const std::string& libname);
/** If check to see if the target is linked to by any other
target in the project */
bool IsDependedOn(const char* project, cmTarget* target);
......
......@@ -23,7 +23,6 @@ PURPOSE. See the above copyright notices for more information.
#include "cmake.h"
#include "cmGeneratedFileStream.h"
#include "cmSourceFile.h"
#include "cmOrderLinkDirectories.h"
//----------------------------------------------------------------------------
#if defined(CMAKE_BUILD_WITH_CMAKE)
......@@ -427,18 +426,6 @@ cmXCodeObject* cmGlobalXCodeGenerator
return obj;
}
//----------------------------------------------------------------------------
bool IsResource(cmSourceFile* sf)
{
const char* location = sf->GetProperty("MACOSX_PACKAGE_LOCATION");
bool isResource =
(sf->GetPropertyAsBool("FRAMEWORK_RESOURCE") ||
(location && cmStdString(location) == "Resources"));
return isResource;
}
//----------------------------------------------------------------------------
cmStdString GetGroupMapKey(cmTarget& cmtarget, cmSourceFile* sf)
{
......@@ -449,8 +436,8 @@ cmStdString GetGroupMapKey(cmTarget& cmtarget, cmSourceFile* sf)
}
//----------------------------------------------------------------------------
cmXCodeObject*
cmGlobalXCodeGenerator::CreateXCodeSourceFile(cmLocalGenerator* lg,
cmXCodeObject*
cmGlobalXCodeGenerator::CreateXCodeSourceFile(cmLocalGenerator* lg,
cmSourceFile* sf,
cmTarget& cmtarget)
{
......@@ -498,7 +485,8 @@ cmGlobalXCodeGenerator::CreateXCodeSourceFile(cmLocalGenerator* lg,
// Is this a resource file in this target? Add it to the resources group...
//
bool isResource = IsResource(sf);
cmTarget::SourceFileFlags tsFlags = cmtarget.GetTargetSourceFileFlags(sf);
bool isResource = tsFlags.Resource;
// Is this a "private" or "public" framework header file?
// Set the ATTRIBUTES attribute appropriately...
......@@ -506,14 +494,14 @@ cmGlobalXCodeGenerator::CreateXCodeSourceFile(cmLocalGenerator* lg,
if(cmtarget.GetType() == cmTarget::SHARED_LIBRARY &&
cmtarget.GetPropertyAsBool("FRAMEWORK"))
{
if(sf->GetPropertyAsBool("FRAMEWORK_PRIVATE_HEADER"))
if(tsFlags.PrivateHeader)
{
cmXCodeObject* attrs = this->CreateObject(cmXCodeObject::OBJECT_LIST);
attrs->AddObject(this->CreateString("Private"));
settings->AddAttribute("ATTRIBUTES", attrs);
isResource = true;
}
else if(sf->GetPropertyAsBool("FRAMEWORK_PUBLIC_HEADER"))
else if(tsFlags.PublicHeader)
{
cmXCodeObject* attrs = this->CreateObject(cmXCodeObject::OBJECT_LIST);
attrs->AddObject(this->CreateString("Public"));
......@@ -693,6 +681,9 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
cmXCodeObject* filetype =
fr->GetObject()->GetObject("lastKnownFileType");
cmTarget::SourceFileFlags tsFlags =
cmtarget.GetTargetSourceFileFlags(*i);
if(strcmp(filetype->GetString(), "\"compiled.mach-o.objfile\"") == 0)
{
externalObjFiles.push_back(xsf);
......@@ -701,7 +692,7 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
{
headerFiles.push_back(xsf);
}
else if(IsResource(*i))
else if(tsFlags.Resource)
{
resourceFiles.push_back(xsf);
}
......@@ -813,8 +804,8 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
}
copyFilesBuildPhase->AddAttribute("dstPath",
this->CreateString(ostr.str().c_str()));
copyFilesBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
this->CreateString("0"));
copyFilesBuildPhase->AddAttribute(
"runOnlyForDeploymentPostprocessing", this->CreateString("0"));
buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
copyFilesBuildPhase->AddAttribute("files", buildFiles);
std::vector<cmSourceFile*>::iterator sfIt;
......@@ -1418,6 +1409,14 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
productType = "com.apple.product-type.framework";
const char* version = target.GetProperty("FRAMEWORK_VERSION");
if(!version)
{
version = target.GetProperty("VERSION");
}
if(!version)
{
version = "A";
}
buildSettings->AddAttribute("FRAMEWORK_VERSION",
this->CreateString(version));
}
......@@ -1501,7 +1500,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
for(std::vector<std::string>::iterator i = includes.begin();
i != includes.end(); ++i)
{
if(cmSystemTools::IsPathToFramework(i->c_str()))
if(this->NameResolvesToFramework(i->c_str()))
{
std::string frameworkDir = *i;
frameworkDir += "/../";
......@@ -1927,9 +1926,22 @@ void cmGlobalXCodeGenerator::AppendOrAddBuildSetting(cmXCodeObject* settings,
else
{
std::string oldValue = attr->GetString();
cmSystemTools::ReplaceString(oldValue, "\"", "");
// unescape escaped quotes internal to the string:
cmSystemTools::ReplaceString(oldValue, "\\\"", "\"");
// remove surrounding quotes, if any:
std::string::size_type len = oldValue.length();
if(oldValue[0] == '\"' && oldValue[len-1] == '\"')
{
oldValue = oldValue.substr(1, len-2);
}
oldValue += " ";
oldValue += value;
// SetString automatically escapes internal quotes and then surrounds
// the result with quotes if necessary...
attr->SetString(oldValue.c_str());
}
}
......@@ -2098,8 +2110,8 @@ void cmGlobalXCodeGenerator
{
// now add the same one but append $(CONFIGURATION) to it:
linkDirs += " ";
linkDirs += this->XCodeEscapePath(libDir->c_str());
linkDirs += "/$(CONFIGURATION)";
linkDirs += this->XCodeEscapePath(
(*libDir + "/$(CONFIGURATION)").c_str());
}
linkDirs += " ";
linkDirs += this->XCodeEscapePath(libDir->c_str());
......@@ -2506,8 +2518,8 @@ cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
// one more pass for external depend information not handled
// correctly by xcode
makefileStream << "# DO NOT EDIT\n";
makefileStream << "# This makefile makes sure all linkable targets are \n";
makefileStream << "# up-to-date with anything they link to,avoiding a "
makefileStream << "# This makefile makes sure all linkable targets are\n";
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();
......@@ -2826,10 +2838,13 @@ cmGlobalXCodeGenerator
{
if(dir.find(".framework") != dir.npos)
{
// Remove trailing slashes (so that the rfind does not find the one at
// the very end...!)
//
cmSystemTools::ConvertToUnixSlashes(dir);
std::string::size_type pos = dir.rfind("/");
std::string framework = dir.substr(pos);
std::string newDir;
newDir = dir.substr(0, pos);
std::string newDir = dir.substr(0, pos);
newDir += "/";
newDir += config;
dir = newDir;
......
......@@ -175,9 +175,9 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
cmCAStringVector runtimeArgVector (&argHelper, "RUNTIME", &group);
cmCAStringVector frameworkArgVector (&argHelper, "FRAMEWORK", &group);
cmCAStringVector bundleArgVector (&argHelper, "BUNDLE", &group);
cmCAStringVector resourcesArgVector (&argHelper, "RESOURCE", &group);
cmCAStringVector publicHeaderArgVector(&argHelper, "PUBLIC_HEADER", &group);
cmCAStringVector privateHeaderArgVector(&argHelper,"PRIVATE_HEADER", &group);
cmCAStringVector publicHeaderArgVector(&argHelper, "PUBLIC_HEADER", &group);
cmCAStringVector resourceArgVector (&argHelper, "RESOURCE", &group);
genericArgVector.Follows(0);
group.Follows(&genericArgVector);
......@@ -197,18 +197,18 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
cmInstallCommandArguments runtimeArgs;
cmInstallCommandArguments frameworkArgs;
cmInstallCommandArguments bundleArgs;
cmInstallCommandArguments resourcesArgs;
cmInstallCommandArguments publicHeaderArgs;
cmInstallCommandArguments privateHeaderArgs;
cmInstallCommandArguments publicHeaderArgs;
cmInstallCommandArguments resourceArgs;
archiveArgs.Parse (&archiveArgVector.GetVector(), &unknownArgs);
libraryArgs.Parse (&libraryArgVector.GetVector(), &unknownArgs);
runtimeArgs.Parse (&runtimeArgVector.GetVector(), &unknownArgs);
frameworkArgs.Parse (&frameworkArgVector.GetVector(), &unknownArgs);
bundleArgs.Parse (&bundleArgVector.GetVector(), &unknownArgs);
resourcesArgs.Parse (&resourcesArgVector.GetVector(), &unknownArgs);
publicHeaderArgs.Parse (&publicHeaderArgVector.GetVector(), &unknownArgs);
privateHeaderArgs.Parse(&privateHeaderArgVector.GetVector(), &unknownArgs);
publicHeaderArgs.Parse (&publicHeaderArgVector.GetVector(), &unknownArgs);
resourceArgs.Parse (&resourceArgVector.GetVector(), &unknownArgs);
if(!unknownArgs.empty())
{
......@@ -225,18 +225,18 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
runtimeArgs.SetGenericArguments(&genericArgs);
frameworkArgs.SetGenericArguments(&genericArgs);
bundleArgs.SetGenericArguments(&genericArgs);
resourcesArgs.SetGenericArguments(&genericArgs);
publicHeaderArgs.SetGenericArguments(&genericArgs);
privateHeaderArgs.SetGenericArguments(&genericArgs);
publicHeaderArgs.SetGenericArguments(&genericArgs);
resourceArgs.SetGenericArguments(&genericArgs);
success = success && archiveArgs.Finalize();
success = success && libraryArgs.Finalize();
success = success && runtimeArgs.Finalize();
success = success && frameworkArgs.Finalize();
success = success && bundleArgs.Finalize();
success = success && resourcesArgs.Finalize();
success = success && publicHeaderArgs.Finalize();
success = success && privateHeaderArgs.Finalize();
success = success && publicHeaderArgs.Finalize();
success = success && resourceArgs.Finalize();
if(!success)
{
......@@ -299,9 +299,9 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
cmInstallTargetGenerator* runtimeGenerator = 0;
cmInstallTargetGenerator* frameworkGenerator = 0;
cmInstallTargetGenerator* bundleGenerator = 0;
cmInstallFilesGenerator* resourcesGenerator = 0;
cmInstallFilesGenerator* publicHeaderGenerator = 0;
cmInstallFilesGenerator* privateHeaderGenerator = 0;
cmInstallFilesGenerator* publicHeaderGenerator = 0;
cmInstallFilesGenerator* resourceGenerator = 0;
switch(target.GetType())
{
......@@ -465,84 +465,98 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
// if(target.GetProperty("ASSOCIATED_FILES");
const char* files = target.GetProperty("PUBLIC_HEADER");
if ((files) && (*files))
{
std::vector<std::string> relFiles;
cmSystemTools::ExpandListArgument(files, relFiles);
std::vector<std::string> absFiles;
if (!this->MakeFilesFullPath("PUBLIC_HEADER", relFiles, absFiles))
{
return false;
}
// These well-known sets of files are installed *automatically* for FRAMEWORK
// SHARED library targets on the Mac as part of installing the FRAMEWORK.
// For other target types or on other platforms, they are not installed
// automatically and so we need to create install files generators for them.
//
bool createInstallGeneratorsForTargetFileSets = true;
// Create the files install generator.
if (!publicHeaderArgs.GetDestination().empty())
{
publicHeaderGenerator = CreateInstallFilesGenerator(absFiles,
publicHeaderArgs, false);
}
else
{
cmOStringStream e;
e << "TARGETS given no PUBLIC_HEADER DESTINATION for header files\""
<< target.GetName() << "\".";
this->SetError(e.str().c_str());
return false;
}
if(cmTarget::SHARED_LIBRARY == target.GetType() &&
target.GetPropertyAsBool("FRAMEWORK") &&
this->Makefile->IsOn("APPLE"))
{
createInstallGeneratorsForTargetFileSets = false;
}
files = target.GetProperty("PRIVATE_HEADER");
if ((files) && (*files))
if(createInstallGeneratorsForTargetFileSets)
{
std::vector<std::string> relFiles;
cmSystemTools::ExpandListArgument(files, relFiles);
std::vector<std::string> absFiles;
if (!this->MakeFilesFullPath("PRIVATE_HEADER", relFiles, absFiles))
const char* files = target.GetProperty("PRIVATE_HEADER");
if ((files) && (*files))
{
return false;
}
std::vector<std::string> relFiles;
cmSystemTools::ExpandListArgument(files, relFiles);
std::vector<std::string> absFiles;
if (!this->MakeFilesFullPath("PRIVATE_HEADER", relFiles, absFiles))
{
return false;
}
// Create the files install generator.
if (!privateHeaderArgs.GetDestination().empty())
{
privateHeaderGenerator = CreateInstallFilesGenerator(absFiles,
// Create the files install generator.
if (!privateHeaderArgs.GetDestination().empty())
{
privateHeaderGenerator = CreateInstallFilesGenerator(absFiles,
privateHeaderArgs, false);
}
else
{
cmOStringStream e;
e << "INSTALL TARGETS - target " << target.GetName() << " has "
<< "PRIVATE_HEADER files but no PRIVATE_HEADER DESTINATION.";
cmSystemTools::Message(e.str().c_str(), "Warning");
}
}
else
{
cmOStringStream e;
e << "TARGETS given no PRIVATE_HEADER DESTINATION for header files\""
<< target.GetName() << "\".";
this->SetError(e.str().c_str());
return false;
}
}
files = target.GetProperty("RESOURCE_FILES");
if ((files) && (*files))
{
std::vector<std::string> relFiles;
cmSystemTools::ExpandListArgument(files, relFiles);
std::vector<std::string> absFiles;
if (!this->MakeFilesFullPath("RESOURCE_FILES", relFiles, absFiles))
files = target.GetProperty("PUBLIC_HEADER");
if ((files) && (*files))
{
return false;
}
std::vector<std::string> relFiles;
cmSystemTools::ExpandListArgument(files, relFiles);
std::vector<std::string> absFiles;
if (!this->MakeFilesFullPath("PUBLIC_HEADER", relFiles, absFiles))
{
return false;
}
// Create the files install generator.
if (!privateHeaderArgs.GetDestination().empty())
{
resourcesGenerator = CreateInstallFilesGenerator(absFiles,
resourcesArgs, false);
// Create the files install generator.
if (!publicHeaderArgs.GetDestination().empty())
{
publicHeaderGenerator = CreateInstallFilesGenerator(absFiles,
publicHeaderArgs, false);
}
else
{
cmOStringStream e;
e << "INSTALL TARGETS - target " << target.GetName() << " has "
<< "PUBLIC_HEADER files but no PUBLIC_HEADER DESTINATION.";
cmSystemTools::Message(e.str().c_str(), "Warning");
}
}
else
files = target.GetProperty("RESOURCE");
if ((files) && (*files))
{
cmOStringStream e;
e << "TARGETS given no RESOURCES DESTINATION for resource files\""
<< target.GetName() << "\".";
this->SetError(e.str().c_str());
return false;
std::vector<std::string> relFiles;
cmSystemTools::ExpandListArgument(files, relFiles);
std::vector<std::string> absFiles;
if (!this->MakeFilesFullPath("RESOURCE", relFiles, absFiles))
{
return false;
}
// Create the files install generator.
if (!resourceArgs.GetDestination().empty())
{
resourceGenerator = CreateInstallFilesGenerator(absFiles,
resourceArgs, false);
}
else
{
cmOStringStream e;
e << "INSTALL TARGETS - target " << target.GetName() << " has "
<< "RESOURCE files but no RESOURCE DESTINATION.";
cmSystemTools::Message(e.str().c_str(), "Warning");
}
}
}
......@@ -551,9 +565,9 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
this->Makefile->AddInstallGenerator(runtimeGenerator);
this->Makefile->AddInstallGenerator(frameworkGenerator);
this->Makefile->AddInstallGenerator(bundleGenerator);
this->Makefile->AddInstallGenerator(publicHeaderGenerator);
this->Makefile->AddInstallGenerator(privateHeaderGenerator);
this->Makefile->AddInstallGenerator(resourcesGenerator);
this->Makefile->AddInstallGenerator(publicHeaderGenerator);
this->Makefile->AddInstallGenerator(resourceGenerator);
if (!exports.GetString().empty())
{
......@@ -577,11 +591,11 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
this->Makefile->GetLocalGenerator()->GetGlobalGenerator()
->AddInstallComponent(bundleArgs.GetComponent().c_str());
this->Makefile->GetLocalGenerator()->GetGlobalGenerator()
->AddInstallComponent(resourcesArgs.GetComponent().c_str());
->AddInstallComponent(privateHeaderArgs.GetComponent().c_str());
this->Makefile->GetLocalGenerator()->GetGlobalGenerator()
->AddInstallComponent(publicHeaderArgs.GetComponent().c_str());
this->Makefile->GetLocalGenerator()->GetGlobalGenerator()
->AddInstallComponent(privateHeaderArgs.GetComponent().c_str());
->AddInstallComponent(resourceArgs.GetComponent().c_str());
return true;
}
......
......@@ -238,8 +238,18 @@ cmInstallTargetGenerator
{
// Compute the build tree location of the framework directory
std::string from1 = fromDirConfig;
// Remove trailing slashes
cmSystemTools::ConvertToUnixSlashes(from1);
if(config && *config)
{
from1 += "/";
from1 += targetName;
from1 += ".framework";
}
else
{
// Remove trailing slashes... so that from1 ends with ".framework":
//
cmSystemTools::ConvertToUnixSlashes(from1);
}
files.push_back(from1);
type = cmTarget::INSTALL_DIRECTORY;
......
......@@ -252,16 +252,12 @@ void cmMakefileLibraryTargetGenerator::CreateFrameworkLinksAndDirs(
symlink2 = "Resources";
cmSystemTools::CreateSymlink(symlink.c_str(), symlink2.c_str());
this->Makefile->AddCMakeOutputFile((outpath + "Resources").c_str());
// Libraries -> Versions/Current/Libraries
//symlink = "Versions/Current/Libraries";
//symlink2 = "Libraries";
//cmSystemTools::CreateSymlink(symlink.c_str(), symlink2.c_str());
//this->Makefile->AddCMakeOutputFile((outpath + "Libraries").c_str());
// Headers -> Versions/Current/Headers
symlink = "Versions/Current/Headers";
symlink2 = "Headers";
cmSystemTools::CreateSymlink(symlink.c_str(), symlink2.c_str());
this->Makefile->AddCMakeOutputFile((outpath + "Headers").c_str());
// PrivateHeaders -> Versions/Current/PrivateHeaders
symlink = "Versions/Current/PrivateHeaders";
symlink2 = "PrivateHeaders";
cmSystemTools::CreateSymlink(symlink.c_str(), symlink2.c_str());
......@@ -278,12 +274,14 @@ void cmMakefileLibraryTargetGenerator::CopyFrameworkSources(
const char* propertyName,
const char* subdir)
{
std::string fullOutput= outpath + targetName;
std::string fullOutput = outpath + targetName;
cmCustomCommandLines commandLines;
std::vector<std::string> depends;
const std::vector<cmSourceFile*>& sources =
this->Target->GetSourceFiles();
std::string propName(propertyName);
for(std::vector<cmSourceFile*>::const_iterator i = sources.begin();
i != sources.end(); ++i)
{
......@@ -296,16 +294,20 @@ void cmMakefileLibraryTargetGenerator::CopyFrameworkSources(
continue;
}
cmTarget::SourceFileFlags tsFlags =
this->Target->GetTargetSourceFileFlags(sf);
// If processing public headers, skip headers also marked with the private
// property. Private wins.
//
if((std::string(propertyName) == "FRAMEWORK_PUBLIC_HEADER") &&
sf->GetPropertyAsBool("FRAMEWORK_PRIVATE_HEADER"))
if(tsFlags.PrivateHeader && (propName == "PUBLIC_HEADER"))
{
continue;
}
if(sf->GetPropertyAsBool(propertyName))
if(tsFlags.PrivateHeader && (propName == "PRIVATE_HEADER") ||
tsFlags.PublicHeader && (propName == "PUBLIC_HEADER") ||
tsFlags.Resource && (propName == "RESOURCE"))
{
cmCustomCommandLine line;
std::string dest = outpath + subdir + "/";
......@@ -318,8 +320,7 @@ void cmMakefileLibraryTargetGenerator::CopyFrameworkSources(
line.push_back(dest);
commandLines.push_back(line);
// make sure the target gets rebuilt if any of the headers is removed
this->GenerateExtraOutput(dest.c_str(),
fullOutput.c_str());
this->GenerateExtraOutput(dest.c_str(), fullOutput.c_str());
}
}
......@@ -343,14 +344,13 @@ void cmMakefileLibraryTargetGenerator::CreateFramework(
{
std::string macdir = outpath;
const char* version = this->Target->GetProperty("FRAMEWORK_VERSION");
if(!version)
{
version = this->Target->GetProperty("VERSION");
}
if(!version)
{
version = "A";
//std::string message =
// "Warning: FRAMEWORK_VERSION property not found on ";
//message += targetName;
//message += ". Default to version A.";
//cmSystemTools::Message(message.c_str());
}
// create the symbolic links and directories
this->CreateFrameworkLinksAndDirs(targetName,
......@@ -383,13 +383,13 @@ void cmMakefileLibraryTargetGenerator::CreateFramework(
false, false, false);
this->CopyFrameworkSources(targetName, outpath, version,
"FRAMEWORK_PRIVATE_HEADER", "PrivateHeaders");
"PRIVATE_HEADER", "PrivateHeaders");
this->CopyFrameworkSources(targetName, outpath, version,
"FRAMEWORK_PUBLIC_HEADER", "Headers");
"PUBLIC_HEADER", "Headers");
this->CopyFrameworkSources(targetName, outpath, version,
"FRAMEWORK_RESOURCE", "Resources");
"RESOURCE", "Resources");
}
//----------------------------------------------------------------------------
......
......@@ -1170,7 +1170,7 @@ std::string cmMakefileTargetGenerator::GetFrameworkFlags()