Source/cmPolicies.cxx - third_party/cmake - Git at Google

 #include "cmPolicies.h"
 #include "cmake.h"
 #include "cmMakefile.h"
 #include "cmSourceFile.h"
 #include "cmVersion.h"
 #include "cmVersionMacros.h"
 #include <map>
 #include <set>
 #include <queue>
 #include <assert.h>

 const char* cmPolicies::PolicyStatusNames[] = {
   "OLD", "WARN", "NEW", "REQUIRED_IF_USED", "REQUIRED_ALWAYS"
 };

 class cmPolicy
 {
 public:
   cmPolicy(cmPolicies::PolicyID iD,
             const char *idString,
             const char *shortDescription,
             unsigned int majorVersionIntroduced,
             unsigned int minorVersionIntroduced,
             unsigned int patchVersionIntroduced,
             cmPolicies::PolicyStatus status)
   {
     if (!idString || !shortDescription)
       {
       cmSystemTools::Error("Attempt to define a policy without "
         "all parameters being specified!");
       return;
       }
     this->ID = iD;
     this->IDString = idString;
     this->ShortDescription = shortDescription;
     this->MajorVersionIntroduced = majorVersionIntroduced;
     this->MinorVersionIntroduced = minorVersionIntroduced;
     this->PatchVersionIntroduced = patchVersionIntroduced;
     this->Status = status;
   }

   std::string GetVersionString()
   {
     cmOStringStream v;
     v << this->MajorVersionIntroduced << "." << this->MinorVersionIntroduced;
     if(this->PatchVersionIntroduced > 0)
       {
       v << "." << this->PatchVersionIntroduced;
       }
     return v.str();
   }

   bool IsPolicyNewerThan(unsigned int majorV,
                          unsigned int minorV,
                          unsigned int patchV)
   {
     if (majorV < this->MajorVersionIntroduced)
       {
       return true;
       }
     if (majorV > this->MajorVersionIntroduced)
       {
       return false;
       }
     if (minorV < this->MinorVersionIntroduced)
       {
       return true;
       }
     if (minorV > this->MinorVersionIntroduced)
       {
       return false;
       }
     return (patchV < this->PatchVersionIntroduced);
   }

   cmPolicies::PolicyID ID;
   std::string IDString;
   std::string ShortDescription;
   unsigned int MajorVersionIntroduced;
   unsigned int MinorVersionIntroduced;
   unsigned int PatchVersionIntroduced;
   cmPolicies::PolicyStatus Status;
 };

 cmPolicies::cmPolicies()
 {
   // define all the policies
   this->DefinePolicy(
     CMP0000, "CMP0000",
     "A minimum required CMake version must be specified.",
     2,6,0, cmPolicies::WARN
     );

   this->DefinePolicy(
     CMP0001, "CMP0001",
     "CMAKE_BACKWARDS_COMPATIBILITY should no longer be used.",
     2,6,0, cmPolicies::WARN
     );

   this->DefinePolicy(
     CMP0002, "CMP0002",
     "Logical target names must be globally unique.",
     2,6,0, cmPolicies::WARN
     );

   this->DefinePolicy(
     CMP0003, "CMP0003",
     "Libraries linked via full path no longer produce linker search paths.",
     2,6,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0004, "CMP0004",
     "Libraries linked may not have leading or trailing whitespace.",
     2,6,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0005, "CMP0005",
     "Preprocessor definition values are now escaped automatically.",
     2,6,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0006, "CMP0006",
     "Installing MACOSX_BUNDLE targets requires a BUNDLE DESTINATION.",
     2,6,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0007, "CMP0007",
     "list command no longer ignores empty elements.",
     2,6,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0008, "CMP0008",
     "Libraries linked by full-path must have a valid library file name.",
     2,6,1, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0009, "CMP0009",
     "FILE GLOB_RECURSE calls should not follow symlinks by default.",
     2,6,2, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0010, "CMP0010",
     "Bad variable reference syntax is an error.",
     2,6,3, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0011, "CMP0011",
     "Included scripts do automatic cmake_policy PUSH and POP.",
     2,6,3, cmPolicies::WARN);

     this->DefinePolicy(
     CMP0012, "CMP0012",
     "if() recognizes numbers and boolean constants.",
     2,8,0, cmPolicies::WARN);

     this->DefinePolicy(
     CMP0013, "CMP0013",
     "Duplicate binary directories are not allowed.",
     2,8,0, cmPolicies::WARN);

     this->DefinePolicy(
     CMP0014, "CMP0014",
     "Input directories must have CMakeLists.txt.",
     2,8,0, cmPolicies::WARN);

     this->DefinePolicy(
     CMP0015, "CMP0015",
     "link_directories() treats paths relative to the source dir.",
     2,8,1, cmPolicies::WARN);

     this->DefinePolicy(
     CMP0016, "CMP0016",
     "target_link_libraries() reports error if its only argument "
     "is not a target.",
     2,8,3, cmPolicies::WARN);

     this->DefinePolicy(
     CMP0017, "CMP0017",
     "Prefer files from the CMake module directory when including from there.",
     2,8,4, cmPolicies::WARN);

     this->DefinePolicy(
     CMP0018, "CMP0018",
     "Ignore CMAKE_SHARED_LIBRARY_<Lang>_FLAGS variable.",
     2,8,9, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0019, "CMP0019",
     "Do not re-expand variables in include and link information.",
     2,8,11, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0020, "CMP0020",
     "Automatically link Qt executables to qtmain target on Windows.",
     2,8,11, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0021, "CMP0021",
     "Fatal error on relative paths in INCLUDE_DIRECTORIES target property.",
     2,8,12, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0022, "CMP0022",
     "INTERFACE_LINK_LIBRARIES defines the link interface.",
     2,8,12, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0023, "CMP0023",
     "Plain and keyword target_link_libraries signatures cannot be mixed.",
     2,8,12, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0024, "CMP0024",
     "Disallow include export result.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0025, "CMP0025",
     "Compiler id for Apple Clang is now AppleClang.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0026, "CMP0026",
     "Disallow use of the LOCATION target property.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0027, "CMP0027",
     "Conditionally linked imported targets with missing include directories.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0028, "CMP0028",
     "Double colon in target name means ALIAS or IMPORTED target.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0029, "CMP0029",
     "The subdir_depends command should not be called.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0030, "CMP0030",
     "The use_mangled_mesa command should not be called.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0031, "CMP0031",
     "The load_command command should not be called.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0032, "CMP0032",
     "The output_required_files command should not be called.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0033, "CMP0033",
     "The export_library_dependencies command should not be called.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0034, "CMP0034",
     "The utility_source command should not be called.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0035, "CMP0035",
     "The variable_requires command should not be called.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0036, "CMP0036",
     "The build_name command should not be called.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0037, "CMP0037",
     "Target names should not be reserved and should match a validity pattern.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0038, "CMP0038",
     "Targets may not link directly to themselves.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0039, "CMP0039",
     "Utility targets may not have link dependencies.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0040, "CMP0040",
     "The target in the TARGET signature of add_custom_command() must exist.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0041, "CMP0041",
     "Error on relative include with generator expression.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0042, "CMP0042",
     "MACOSX_RPATH is enabled by default.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0043, "CMP0043",
     "Ignore COMPILE_DEFINITIONS_<Config> properties.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0044, "CMP0044",
     "Case sensitive <LANG>_COMPILER_ID generator expressions.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0045, "CMP0045",
     "Error on non-existent target in get_target_property.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0046, "CMP0046",
     "Error on non-existent dependency in add_dependencies.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0047, "CMP0047",
     "Use QCC compiler id for the qcc drivers on QNX.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0048, "CMP0048",
     "project() command manages VERSION variables.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0049, "CMP0049",
     "Do not expand variables in target source entries.",
     3,0,0, cmPolicies::WARN);

   this->DefinePolicy(
     CMP0050, "CMP0050",
     "Disallow add_custom_command SOURCE signatures.",
     3,0,0, cmPolicies::WARN);
 }

 cmPolicies::~cmPolicies()
 {
   // free the policies
   std::map<cmPolicies::PolicyID,cmPolicy *>::iterator i
     = this->Policies.begin();
   for (;i != this->Policies.end(); ++i)
     {
     delete i->second;
     }
 }

 void cmPolicies::DefinePolicy(cmPolicies::PolicyID iD,
                               const char *idString,
                               const char *shortDescription,
                               unsigned int majorVersionIntroduced,
                               unsigned int minorVersionIntroduced,
                               unsigned int patchVersionIntroduced,
                               cmPolicies::PolicyStatus status)
 {
   // a policy must be unique and can only be defined once
   if (this->Policies.find(iD) != this->Policies.end())
     {
     cmSystemTools::Error("Attempt to redefine a CMake policy for policy "
       "ID ", this->GetPolicyIDString(iD).c_str());
     return;
     }

   this->Policies[iD] = new cmPolicy(iD, idString,
                                     shortDescription,
                                     majorVersionIntroduced,
                                     minorVersionIntroduced,
                                     patchVersionIntroduced,
                                     status);
   this->PolicyStringMap[idString] = iD;
 }

 //----------------------------------------------------------------------------
 bool cmPolicies::ApplyPolicyVersion(cmMakefile *mf,
                                     const char *version)
 {
   std::string ver = "2.4.0";

   if (version && strlen(version) > 0)
     {
     ver = version;
     }

   unsigned int majorVer = 2;
   unsigned int minorVer = 0;
   unsigned int patchVer = 0;
   unsigned int tweakVer = 0;

   // parse the string
   if(sscanf(ver.c_str(), "%u.%u.%u.%u",
             &majorVer, &minorVer, &patchVer, &tweakVer) < 2)
     {
     cmOStringStream e;
     e << "Invalid policy version value \"" << ver << "\".  "
       << "A numeric major.minor[.patch[.tweak]] must be given.";
     mf->IssueMessage(cmake::FATAL_ERROR, e.str());
     return false;
     }

   // it is an error if the policy version is less than 2.4
   if (majorVer < 2 || (majorVer == 2 && minorVer < 4))
     {
     mf->IssueMessage(cmake::FATAL_ERROR,
       "Compatibility with CMake < 2.4 is not supported by CMake >= 3.0.  "
       "For compatibility with older versions please use any CMake 2.8.x "
       "release or lower.");
     return false;
     }

   // It is an error if the policy version is greater than the running
   // CMake.
   if (majorVer > cmVersion::GetMajorVersion() ||
       (majorVer == cmVersion::GetMajorVersion() &&
        minorVer > cmVersion::GetMinorVersion()) ||
       (majorVer == cmVersion::GetMajorVersion() &&
        minorVer == cmVersion::GetMinorVersion() &&
        patchVer > cmVersion::GetPatchVersion()) ||
       (majorVer == cmVersion::GetMajorVersion() &&
        minorVer == cmVersion::GetMinorVersion() &&
        patchVer == cmVersion::GetPatchVersion() &&
        tweakVer > cmVersion::GetTweakVersion()))
     {
     cmOStringStream e;
     e << "An attempt was made to set the policy version of CMake to \""
       << version << "\" which is greater than this version of CMake.  "
       << "This is not allowed because the greater version may have new "
       << "policies not known to this CMake.  "
       << "You may need a newer CMake version to build this project.";
     mf->IssueMessage(cmake::FATAL_ERROR, e.str());
     return false;
     }

   // now loop over all the policies and set them as appropriate
   std::vector<cmPolicies::PolicyID> ancientPolicies;
   for(std::map<cmPolicies::PolicyID,cmPolicy *>::iterator i
                      = this->Policies.begin(); i != this->Policies.end(); ++i)
     {
     if (i->second->IsPolicyNewerThan(majorVer,minorVer,patchVer))
       {
       if(i->second->Status == cmPolicies::REQUIRED_ALWAYS)
         {
         ancientPolicies.push_back(i->first);
         }
       else
         {
         cmPolicies::PolicyStatus status = cmPolicies::WARN;
         if(!this->GetPolicyDefault(mf, i->second->IDString, &status) ||
            !mf->SetPolicy(i->second->ID, status))
           {
           return false;
           }
         }
       }
     else
       {
       if (!mf->SetPolicy(i->second->ID, cmPolicies::NEW))
         {
         return false;
         }
       }
     }

   // Make sure the project does not use any ancient policies.
   if(!ancientPolicies.empty())
     {
     this->DiagnoseAncientPolicies(ancientPolicies,
                                   majorVer, minorVer, patchVer, mf);
     cmSystemTools::SetFatalErrorOccured();
     return false;
     }

   return true;
 }

 //----------------------------------------------------------------------------
 bool cmPolicies::GetPolicyDefault(cmMakefile* mf, std::string const& policy,
                                   cmPolicies::PolicyStatus* defaultSetting)
 {
   std::string defaultVar = "CMAKE_POLICY_DEFAULT_" + policy;
   std::string defaultValue = mf->GetSafeDefinition(defaultVar.c_str());
   if(defaultValue == "NEW")
     {
     *defaultSetting = cmPolicies::NEW;
     }
   else if(defaultValue == "OLD")
     {
     *defaultSetting = cmPolicies::OLD;
     }
   else if(defaultValue == "")
     {
     *defaultSetting = cmPolicies::WARN;
     }
   else
     {
     cmOStringStream e;
     e << defaultVar << " has value \"" << defaultValue
       << "\" but must be \"OLD\", \"NEW\", or \"\" (empty).";
     mf->IssueMessage(cmake::FATAL_ERROR, e.str().c_str());
     return false;
     }

   return true;
 }

 bool cmPolicies::GetPolicyID(const char *id, cmPolicies::PolicyID &pid)
 {
   if (!id || strlen(id) < 1)
     {
     return false;
     }
   std::map<std::string,cmPolicies::PolicyID>::iterator pos =
     this->PolicyStringMap.find(id);
   if (pos == this->PolicyStringMap.end())
     {
     return false;
     }
   pid = pos->second;
   return true;
 }

 std::string cmPolicies::GetPolicyIDString(cmPolicies::PolicyID pid)
 {
   std::map<cmPolicies::PolicyID,cmPolicy *>::iterator pos =
     this->Policies.find(pid);
   if (pos == this->Policies.end())
     {
     return "";
     }
   return pos->second->IDString;
 }


 ///! return a warning string for a given policy
 std::string cmPolicies::GetPolicyWarning(cmPolicies::PolicyID id)
 {
   std::map<cmPolicies::PolicyID,cmPolicy *>::iterator pos =
     this->Policies.find(id);
   if (pos == this->Policies.end())
     {
     cmSystemTools::Error(
       "Request for warning text for undefined policy!");
     return "Request for warning text for undefined policy!";
     }

   cmOStringStream msg;
   msg <<
     "Policy " << pos->second->IDString << " is not set: "
     "" << pos->second->ShortDescription << "  "
     "Run \"cmake --help-policy " << pos->second->IDString << "\" for "
     "policy details.  "
     "Use the cmake_policy command to set the policy "
     "and suppress this warning.";
   return msg.str();
 }


 ///! return an error string for when a required policy is unspecified
 std::string cmPolicies::GetRequiredPolicyError(cmPolicies::PolicyID id)
 {
   std::map<cmPolicies::PolicyID,cmPolicy *>::iterator pos =
     this->Policies.find(id);
   if (pos == this->Policies.end())
     {
     cmSystemTools::Error(
       "Request for error text for undefined policy!");
     return "Request for error text for undefined policy!";
     }

   cmOStringStream error;
   error <<
     "Policy " << pos->second->IDString << " is not set to NEW: "
     "" << pos->second->ShortDescription << "  "
     "Run \"cmake --help-policy " << pos->second->IDString << "\" for "
     "policy details.  "
     "CMake now requires this policy to be set to NEW by the project.  "
     "The policy may be set explicitly using the code\n"
     "  cmake_policy(SET " << pos->second->IDString << " NEW)\n"
     "or by upgrading all policies with the code\n"
     "  cmake_policy(VERSION " << pos->second->GetVersionString() <<
     ") # or later\n"
     "Run \"cmake --help-command cmake_policy\" for more information.";
   return error.str();
 }

 ///! Get the default status for a policy
 cmPolicies::PolicyStatus
 cmPolicies::GetPolicyStatus(cmPolicies::PolicyID id)
 {
   // if the policy is not know then what?
   std::map<cmPolicies::PolicyID,cmPolicy *>::iterator pos =
     this->Policies.find(id);
   if (pos == this->Policies.end())
     {
     // TODO is this right?
     return cmPolicies::WARN;
     }

   return pos->second->Status;
 }

 //----------------------------------------------------------------------------
 std::string
 cmPolicies::GetRequiredAlwaysPolicyError(cmPolicies::PolicyID id)
 {
   std::string pid = this->GetPolicyIDString(id);
   cmOStringStream e;
   e << "Policy " << pid << " may not be set to OLD behavior because this "
     << "version of CMake no longer supports it.  "
     << "The policy was introduced in "
     << "CMake version " << this->Policies[id]->GetVersionString()
     << ", and use of NEW behavior is now required."
     << "\n"
     << "Please either update your CMakeLists.txt files to conform to "
     << "the new behavior or use an older version of CMake that still "
     << "supports the old behavior.  "
     << "Run cmake --help-policy " << pid << " for more information.";
   return e.str();
 }

 //----------------------------------------------------------------------------
 void
 cmPolicies::DiagnoseAncientPolicies(std::vector<PolicyID> const& ancient,
                                     unsigned int majorVer,
                                     unsigned int minorVer,
                                     unsigned int patchVer,
                                     cmMakefile* mf)
 {
   cmOStringStream e;
   e << "The project requests behavior compatible with CMake version \""
     << majorVer << "." << minorVer << "." << patchVer
     << "\", which requires the OLD behavior for some policies:\n";
   for(std::vector<PolicyID>::const_iterator
         i = ancient.begin(); i != ancient.end(); ++i)
     {
     cmPolicy const* policy = this->Policies[*i];
     e << "  " << policy->IDString << ": " << policy->ShortDescription << "\n";
     }
   e << "However, this version of CMake no longer supports the OLD "
     << "behavior for these policies.  "
     << "Please either update your CMakeLists.txt files to conform to "
     << "the new behavior or use an older version of CMake that still "
     << "supports the old behavior.";
   mf->IssueMessage(cmake::FATAL_ERROR, e.str().c_str());
 }
	#include "cmPolicies.h"
	#include "cmake.h"
	#include "cmMakefile.h"
	#include "cmSourceFile.h"
	#include "cmVersion.h"
	#include "cmVersionMacros.h"
	#include <map>
	#include <set>
	#include <queue>
	#include <assert.h>

	const char* cmPolicies::PolicyStatusNames[] = {
	"OLD", "WARN", "NEW", "REQUIRED_IF_USED", "REQUIRED_ALWAYS"
	};

	class cmPolicy
	{
	public:
	cmPolicy(cmPolicies::PolicyID iD,
	const char *idString,
	const char *shortDescription,
	unsigned int majorVersionIntroduced,
	unsigned int minorVersionIntroduced,
	unsigned int patchVersionIntroduced,
	cmPolicies::PolicyStatus status)
	{
	if (!idString \|\| !shortDescription)
	{
	cmSystemTools::Error("Attempt to define a policy without "
	"all parameters being specified!");
	return;
	}
	this->ID = iD;
	this->IDString = idString;
	this->ShortDescription = shortDescription;
	this->MajorVersionIntroduced = majorVersionIntroduced;
	this->MinorVersionIntroduced = minorVersionIntroduced;
	this->PatchVersionIntroduced = patchVersionIntroduced;
	this->Status = status;
	}

	std::string GetVersionString()
	{
	cmOStringStream v;
	v << this->MajorVersionIntroduced << "." << this->MinorVersionIntroduced;
	if(this->PatchVersionIntroduced > 0)
	{
	v << "." << this->PatchVersionIntroduced;
	}
	return v.str();
	}

	bool IsPolicyNewerThan(unsigned int majorV,
	unsigned int minorV,
	unsigned int patchV)
	{
	if (majorV < this->MajorVersionIntroduced)
	{
	return true;
	}
	if (majorV > this->MajorVersionIntroduced)
	{
	return false;
	}
	if (minorV < this->MinorVersionIntroduced)
	{
	return true;
	}
	if (minorV > this->MinorVersionIntroduced)
	{
	return false;
	}
	return (patchV < this->PatchVersionIntroduced);
	}

	cmPolicies::PolicyID ID;
	std::string IDString;
	std::string ShortDescription;
	unsigned int MajorVersionIntroduced;
	unsigned int MinorVersionIntroduced;
	unsigned int PatchVersionIntroduced;
	cmPolicies::PolicyStatus Status;
	};

	cmPolicies::cmPolicies()
	{
	// define all the policies
	this->DefinePolicy(
	CMP0000, "CMP0000",
	"A minimum required CMake version must be specified.",
	2,6,0, cmPolicies::WARN
	);

	this->DefinePolicy(
	CMP0001, "CMP0001",
	"CMAKE_BACKWARDS_COMPATIBILITY should no longer be used.",
	2,6,0, cmPolicies::WARN
	);

	this->DefinePolicy(
	CMP0002, "CMP0002",
	"Logical target names must be globally unique.",
	2,6,0, cmPolicies::WARN
	);

	this->DefinePolicy(
	CMP0003, "CMP0003",
	"Libraries linked via full path no longer produce linker search paths.",
	2,6,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0004, "CMP0004",
	"Libraries linked may not have leading or trailing whitespace.",
	2,6,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0005, "CMP0005",
	"Preprocessor definition values are now escaped automatically.",
	2,6,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0006, "CMP0006",
	"Installing MACOSX_BUNDLE targets requires a BUNDLE DESTINATION.",
	2,6,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0007, "CMP0007",
	"list command no longer ignores empty elements.",
	2,6,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0008, "CMP0008",
	"Libraries linked by full-path must have a valid library file name.",
	2,6,1, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0009, "CMP0009",
	"FILE GLOB_RECURSE calls should not follow symlinks by default.",
	2,6,2, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0010, "CMP0010",
	"Bad variable reference syntax is an error.",
	2,6,3, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0011, "CMP0011",
	"Included scripts do automatic cmake_policy PUSH and POP.",
	2,6,3, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0012, "CMP0012",
	"if() recognizes numbers and boolean constants.",
	2,8,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0013, "CMP0013",
	"Duplicate binary directories are not allowed.",
	2,8,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0014, "CMP0014",
	"Input directories must have CMakeLists.txt.",
	2,8,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0015, "CMP0015",
	"link_directories() treats paths relative to the source dir.",
	2,8,1, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0016, "CMP0016",
	"target_link_libraries() reports error if its only argument "
	"is not a target.",
	2,8,3, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0017, "CMP0017",
	"Prefer files from the CMake module directory when including from there.",
	2,8,4, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0018, "CMP0018",
	"Ignore CMAKE_SHARED_LIBRARY_<Lang>_FLAGS variable.",
	2,8,9, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0019, "CMP0019",
	"Do not re-expand variables in include and link information.",
	2,8,11, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0020, "CMP0020",
	"Automatically link Qt executables to qtmain target on Windows.",
	2,8,11, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0021, "CMP0021",
	"Fatal error on relative paths in INCLUDE_DIRECTORIES target property.",
	2,8,12, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0022, "CMP0022",
	"INTERFACE_LINK_LIBRARIES defines the link interface.",
	2,8,12, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0023, "CMP0023",
	"Plain and keyword target_link_libraries signatures cannot be mixed.",
	2,8,12, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0024, "CMP0024",
	"Disallow include export result.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0025, "CMP0025",
	"Compiler id for Apple Clang is now AppleClang.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0026, "CMP0026",
	"Disallow use of the LOCATION target property.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0027, "CMP0027",
	"Conditionally linked imported targets with missing include directories.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0028, "CMP0028",
	"Double colon in target name means ALIAS or IMPORTED target.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0029, "CMP0029",
	"The subdir_depends command should not be called.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0030, "CMP0030",
	"The use_mangled_mesa command should not be called.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0031, "CMP0031",
	"The load_command command should not be called.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0032, "CMP0032",
	"The output_required_files command should not be called.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0033, "CMP0033",
	"The export_library_dependencies command should not be called.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0034, "CMP0034",
	"The utility_source command should not be called.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0035, "CMP0035",
	"The variable_requires command should not be called.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0036, "CMP0036",
	"The build_name command should not be called.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0037, "CMP0037",
	"Target names should not be reserved and should match a validity pattern.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0038, "CMP0038",
	"Targets may not link directly to themselves.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0039, "CMP0039",
	"Utility targets may not have link dependencies.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0040, "CMP0040",
	"The target in the TARGET signature of add_custom_command() must exist.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0041, "CMP0041",
	"Error on relative include with generator expression.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0042, "CMP0042",
	"MACOSX_RPATH is enabled by default.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0043, "CMP0043",
	"Ignore COMPILE_DEFINITIONS_<Config> properties.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0044, "CMP0044",
	"Case sensitive <LANG>_COMPILER_ID generator expressions.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0045, "CMP0045",
	"Error on non-existent target in get_target_property.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0046, "CMP0046",
	"Error on non-existent dependency in add_dependencies.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0047, "CMP0047",
	"Use QCC compiler id for the qcc drivers on QNX.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0048, "CMP0048",
	"project() command manages VERSION variables.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0049, "CMP0049",
	"Do not expand variables in target source entries.",
	3,0,0, cmPolicies::WARN);

	this->DefinePolicy(
	CMP0050, "CMP0050",
	"Disallow add_custom_command SOURCE signatures.",
	3,0,0, cmPolicies::WARN);
	}

	cmPolicies::~cmPolicies()
	{
	// free the policies
	std::map<cmPolicies::PolicyID,cmPolicy *>::iterator i
	= this->Policies.begin();
	for (;i != this->Policies.end(); ++i)
	{
	delete i->second;
	}
	}

	void cmPolicies::DefinePolicy(cmPolicies::PolicyID iD,
	const char *idString,
	const char *shortDescription,
	unsigned int majorVersionIntroduced,
	unsigned int minorVersionIntroduced,
	unsigned int patchVersionIntroduced,
	cmPolicies::PolicyStatus status)
	{
	// a policy must be unique and can only be defined once
	if (this->Policies.find(iD) != this->Policies.end())
	{
	cmSystemTools::Error("Attempt to redefine a CMake policy for policy "
	"ID ", this->GetPolicyIDString(iD).c_str());
	return;
	}

	this->Policies[iD] = new cmPolicy(iD, idString,
	shortDescription,
	majorVersionIntroduced,
	minorVersionIntroduced,
	patchVersionIntroduced,
	status);
	this->PolicyStringMap[idString] = iD;
	}

	//----------------------------------------------------------------------------
	bool cmPolicies::ApplyPolicyVersion(cmMakefile *mf,
	const char *version)
	{
	std::string ver = "2.4.0";

	if (version && strlen(version) > 0)
	{
	ver = version;
	}

	unsigned int majorVer = 2;
	unsigned int minorVer = 0;
	unsigned int patchVer = 0;
	unsigned int tweakVer = 0;

	// parse the string
	if(sscanf(ver.c_str(), "%u.%u.%u.%u",
	&majorVer, &minorVer, &patchVer, &tweakVer) < 2)
	{
	cmOStringStream e;
	e << "Invalid policy version value \"" << ver << "\". "
	<< "A numeric major.minor[.patch[.tweak]] must be given.";
	mf->IssueMessage(cmake::FATAL_ERROR, e.str());
	return false;
	}

	// it is an error if the policy version is less than 2.4
	if (majorVer < 2 \|\| (majorVer == 2 && minorVer < 4))
	{
	mf->IssueMessage(cmake::FATAL_ERROR,
	"Compatibility with CMake < 2.4 is not supported by CMake >= 3.0. "
	"For compatibility with older versions please use any CMake 2.8.x "
	"release or lower.");
	return false;
	}

	// It is an error if the policy version is greater than the running
	// CMake.
	if (majorVer > cmVersion::GetMajorVersion() \|\|
	(majorVer == cmVersion::GetMajorVersion() &&
	minorVer > cmVersion::GetMinorVersion()) \|\|
	(majorVer == cmVersion::GetMajorVersion() &&
	minorVer == cmVersion::GetMinorVersion() &&
	patchVer > cmVersion::GetPatchVersion()) \|\|
	(majorVer == cmVersion::GetMajorVersion() &&
	minorVer == cmVersion::GetMinorVersion() &&
	patchVer == cmVersion::GetPatchVersion() &&
	tweakVer > cmVersion::GetTweakVersion()))
	{
	cmOStringStream e;
	e << "An attempt was made to set the policy version of CMake to \""
	<< version << "\" which is greater than this version of CMake. "
	<< "This is not allowed because the greater version may have new "
	<< "policies not known to this CMake. "
	<< "You may need a newer CMake version to build this project.";
	mf->IssueMessage(cmake::FATAL_ERROR, e.str());
	return false;
	}

	// now loop over all the policies and set them as appropriate
	std::vector<cmPolicies::PolicyID> ancientPolicies;
	for(std::map<cmPolicies::PolicyID,cmPolicy *>::iterator i
	= this->Policies.begin(); i != this->Policies.end(); ++i)
	{
	if (i->second->IsPolicyNewerThan(majorVer,minorVer,patchVer))
	{
	if(i->second->Status == cmPolicies::REQUIRED_ALWAYS)
	{
	ancientPolicies.push_back(i->first);
	}
	else
	{
	cmPolicies::PolicyStatus status = cmPolicies::WARN;
	if(!this->GetPolicyDefault(mf, i->second->IDString, &status) \|\|
	!mf->SetPolicy(i->second->ID, status))
	{
	return false;
	}
	}
	}
	else
	{
	if (!mf->SetPolicy(i->second->ID, cmPolicies::NEW))
	{
	return false;
	}
	}
	}

	// Make sure the project does not use any ancient policies.
	if(!ancientPolicies.empty())
	{
	this->DiagnoseAncientPolicies(ancientPolicies,
	majorVer, minorVer, patchVer, mf);
	cmSystemTools::SetFatalErrorOccured();
	return false;
	}

	return true;
	}

	//----------------------------------------------------------------------------
	bool cmPolicies::GetPolicyDefault(cmMakefile* mf, std::string const& policy,
	cmPolicies::PolicyStatus* defaultSetting)
	{
	std::string defaultVar = "CMAKE_POLICY_DEFAULT_" + policy;
	std::string defaultValue = mf->GetSafeDefinition(defaultVar.c_str());
	if(defaultValue == "NEW")
	{
	*defaultSetting = cmPolicies::NEW;
	}
	else if(defaultValue == "OLD")
	{
	*defaultSetting = cmPolicies::OLD;
	}
	else if(defaultValue == "")
	{
	*defaultSetting = cmPolicies::WARN;
	}
	else
	{
	cmOStringStream e;
	e << defaultVar << " has value \"" << defaultValue
	<< "\" but must be \"OLD\", \"NEW\", or \"\" (empty).";
	mf->IssueMessage(cmake::FATAL_ERROR, e.str().c_str());
	return false;
	}

	return true;
	}

	bool cmPolicies::GetPolicyID(const char *id, cmPolicies::PolicyID &pid)
	{
	if (!id \|\| strlen(id) < 1)
	{
	return false;
	}
	std::map<std::string,cmPolicies::PolicyID>::iterator pos =
	this->PolicyStringMap.find(id);
	if (pos == this->PolicyStringMap.end())
	{
	return false;
	}
	pid = pos->second;
	return true;
	}

	std::string cmPolicies::GetPolicyIDString(cmPolicies::PolicyID pid)
	{
	std::map<cmPolicies::PolicyID,cmPolicy *>::iterator pos =
	this->Policies.find(pid);
	if (pos == this->Policies.end())
	{
	return "";
	}
	return pos->second->IDString;
	}


	///! return a warning string for a given policy
	std::string cmPolicies::GetPolicyWarning(cmPolicies::PolicyID id)
	{
	std::map<cmPolicies::PolicyID,cmPolicy *>::iterator pos =
	this->Policies.find(id);
	if (pos == this->Policies.end())
	{
	cmSystemTools::Error(
	"Request for warning text for undefined policy!");
	return "Request for warning text for undefined policy!";
	}

	cmOStringStream msg;
	msg <<
	"Policy " << pos->second->IDString << " is not set: "
	"" << pos->second->ShortDescription << " "
	"Run \"cmake --help-policy " << pos->second->IDString << "\" for "
	"policy details. "
	"Use the cmake_policy command to set the policy "
	"and suppress this warning.";
	return msg.str();
	}


	///! return an error string for when a required policy is unspecified
	std::string cmPolicies::GetRequiredPolicyError(cmPolicies::PolicyID id)
	{
	std::map<cmPolicies::PolicyID,cmPolicy *>::iterator pos =
	this->Policies.find(id);
	if (pos == this->Policies.end())
	{
	cmSystemTools::Error(
	"Request for error text for undefined policy!");
	return "Request for error text for undefined policy!";
	}

	cmOStringStream error;
	error <<
	"Policy " << pos->second->IDString << " is not set to NEW: "
	"" << pos->second->ShortDescription << " "
	"Run \"cmake --help-policy " << pos->second->IDString << "\" for "
	"policy details. "
	"CMake now requires this policy to be set to NEW by the project. "
	"The policy may be set explicitly using the code\n"
	" cmake_policy(SET " << pos->second->IDString << " NEW)\n"
	"or by upgrading all policies with the code\n"
	" cmake_policy(VERSION " << pos->second->GetVersionString() <<
	") # or later\n"
	"Run \"cmake --help-command cmake_policy\" for more information.";
	return error.str();
	}

	///! Get the default status for a policy
	cmPolicies::PolicyStatus
	cmPolicies::GetPolicyStatus(cmPolicies::PolicyID id)
	{
	// if the policy is not know then what?
	std::map<cmPolicies::PolicyID,cmPolicy *>::iterator pos =
	this->Policies.find(id);
	if (pos == this->Policies.end())
	{
	// TODO is this right?
	return cmPolicies::WARN;
	}

	return pos->second->Status;
	}

	//----------------------------------------------------------------------------
	std::string
	cmPolicies::GetRequiredAlwaysPolicyError(cmPolicies::PolicyID id)
	{
	std::string pid = this->GetPolicyIDString(id);
	cmOStringStream e;
	e << "Policy " << pid << " may not be set to OLD behavior because this "
	<< "version of CMake no longer supports it. "
	<< "The policy was introduced in "
	<< "CMake version " << this->Policies[id]->GetVersionString()
	<< ", and use of NEW behavior is now required."
	<< "\n"
	<< "Please either update your CMakeLists.txt files to conform to "
	<< "the new behavior or use an older version of CMake that still "
	<< "supports the old behavior. "
	<< "Run cmake --help-policy " << pid << " for more information.";
	return e.str();
	}

	//----------------------------------------------------------------------------
	void
	cmPolicies::DiagnoseAncientPolicies(std::vector<PolicyID> const& ancient,
	unsigned int majorVer,
	unsigned int minorVer,
	unsigned int patchVer,
	cmMakefile* mf)
	{
	cmOStringStream e;
	e << "The project requests behavior compatible with CMake version \""
	<< majorVer << "." << minorVer << "." << patchVer
	<< "\", which requires the OLD behavior for some policies:\n";
	for(std::vector<PolicyID>::const_iterator
	i = ancient.begin(); i != ancient.end(); ++i)
	{
	cmPolicy const* policy = this->Policies[*i];
	e << " " << policy->IDString << ": " << policy->ShortDescription << "\n";
	}
	e << "However, this version of CMake no longer supports the OLD "
	<< "behavior for these policies. "
	<< "Please either update your CMakeLists.txt files to conform to "
	<< "the new behavior or use an older version of CMake that still "
	<< "supports the old behavior.";
	mf->IssueMessage(cmake::FATAL_ERROR, e.str().c_str());
	}