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

 /*============================================================================
   CMake - Cross Platform Makefile Generator
   Copyright 2000-2009 Kitware, Inc., Insight Software Consortium

   Distributed under the OSI-approved BSD License (the "License");
   see accompanying file Copyright.txt for details.

   This software is distributed WITHOUT ANY WARRANTY; without even the
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the License for more information.
 ============================================================================*/
 #include "cmFindLibraryCommand.h"
 #include "cmCacheManager.h"
 #include <cmsys/Directory.hxx>
 #include <cmsys/stl/algorithm>

 cmFindLibraryCommand::cmFindLibraryCommand()
 {
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "FIND_XXX", "find_library");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "CMAKE_XXX_PATH", "CMAKE_LIBRARY_PATH");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "CMAKE_XXX_MAC_PATH",
                                "CMAKE_FRAMEWORK_PATH");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "CMAKE_SYSTEM_XXX_MAC_PATH",
                                "CMAKE_SYSTEM_FRAMEWORK_PATH");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "XXX_SYSTEM", "LIB");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "CMAKE_SYSTEM_XXX_PATH",
                                "CMAKE_SYSTEM_LIBRARY_PATH");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "SEARCH_XXX_DESC", "library");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "SEARCH_XXX", "library");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "XXX_SUBDIR", "lib");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "CMAKE_FIND_ROOT_PATH_MODE_XXX",
                                "CMAKE_FIND_ROOT_PATH_MODE_LIBRARY");

   this->EnvironmentPath = "LIB";
   this->GenericDocumentation +=
     "\n"
     "If the library found is a framework, then VAR will be set to "
     "the full path to the framework <fullPath>/A.framework. "
     "When a full path to a framework is used as a library, "
     "CMake will use a -framework A, and a -F<fullPath> to "
     "link the framework to the target. ";
 }

 // cmFindLibraryCommand
 bool cmFindLibraryCommand
 ::InitialPass(std::vector<std::string> const& argsIn, cmExecutionStatus &)
 {
   this->VariableDocumentation = "Path to a library.";
   this->CMakePathName = "LIBRARY";
   if(!this->ParseArguments(argsIn))
     {
     return false;
     }
   if(this->AlreadyInCache)
     {
     // If the user specifies the entry on the command line without a
     // type we should add the type and docstring but keep the original
     // value.
     if(this->AlreadyInCacheWithoutMetaInfo)
       {
       this->Makefile->AddCacheDefinition(this->VariableName.c_str(), "",
                                          this->VariableDocumentation.c_str(),
                                          cmCacheManager::FILEPATH);
       }
     return true;
     }

   if(const char* abi_name =
      this->Makefile->GetDefinition("CMAKE_INTERNAL_PLATFORM_ABI"))
     {
     std::string abi = abi_name;
     if(abi.find("ELF N32") != abi.npos)
       {
       // Convert lib to lib32.
       this->AddArchitecturePaths("32");
       }
     }

   if(this->Makefile->GetCMakeInstance()
      ->GetPropertyAsBool("FIND_LIBRARY_USE_LIB64_PATHS"))
     {
     // add special 64 bit paths if this is a 64 bit compile.
     this->AddLib64Paths();
     }

   std::string library = this->FindLibrary();
   if(library != "")
     {
     // Save the value in the cache
     this->Makefile->AddCacheDefinition(this->VariableName.c_str(),
                                        library.c_str(),
                                        this->VariableDocumentation.c_str(),
                                        cmCacheManager::FILEPATH);
     return true;
     }
   std::string notfound = this->VariableName + "-NOTFOUND";
   this->Makefile->AddCacheDefinition(this->VariableName.c_str(),
                                      notfound.c_str(),
                                      this->VariableDocumentation.c_str(),
                                      cmCacheManager::FILEPATH);
   return true;
 }

 //----------------------------------------------------------------------------
 void cmFindLibraryCommand::AddArchitecturePaths(const char* suffix)
 {
   std::vector<std::string> newPaths;
   bool found = false;
   std::string subpath = "lib";
   subpath += suffix;
   subpath += "/";
   for(std::vector<std::string>::iterator i = this->SearchPaths.begin();
       i != this->SearchPaths.end(); ++i)
     {
     // Try replacing lib/ with lib<suffix>/
     std::string s = *i;
     cmSystemTools::ReplaceString(s, "lib/", subpath.c_str());
     if((s != *i) && cmSystemTools::FileIsDirectory(s.c_str()))
       {
       found = true;
       newPaths.push_back(s);
       }

     // Now look for lib<suffix>
     s = *i;
     s += suffix;
     if(cmSystemTools::FileIsDirectory(s.c_str()))
       {
       found = true;
       newPaths.push_back(s);
       }
     // now add the original unchanged path
     if(cmSystemTools::FileIsDirectory(i->c_str()))
       {
       newPaths.push_back(*i);
       }
     }

   // If any new paths were found replace the original set.
   if(found)
     {
     this->SearchPaths = newPaths;
     }
 }

 void cmFindLibraryCommand::AddLib64Paths()
 {
   if(!this->Makefile->GetLocalGenerator()->GetGlobalGenerator()->
      GetLanguageEnabled("C"))
     {
     return;
     }
   std::string voidsize =
     this->Makefile->GetSafeDefinition("CMAKE_SIZEOF_VOID_P");
   int size = atoi(voidsize.c_str());
   if(size != 8)
     {
     return;
     }
   std::vector<std::string> path64;
   bool found64 = false;
   for(std::vector<std::string>::iterator i = this->SearchPaths.begin();
       i != this->SearchPaths.end(); ++i)
     {
     std::string s = *i;
     std::string s2 = *i;
     cmSystemTools::ReplaceString(s, "lib/", "lib64/");
     // try to replace lib with lib64 and see if it is there,
     // then prepend it to the path
     // Note that all paths have trailing slashes.
     if((s != *i) && cmSystemTools::FileIsDirectory(s.c_str()))
       {
       path64.push_back(s);
       found64 = true;
       }
     // now just add a 64 to the path name and if it is there,
     // add it to the path
     s2 += "64/";
     if(cmSystemTools::FileIsDirectory(s2.c_str()))
       {
       found64 = true;
       path64.push_back(s2);
       }
     // now add the original unchanged path
     if(cmSystemTools::FileIsDirectory(i->c_str()))
       {
       path64.push_back(*i);
       }
     }
   // now replace the SearchPaths with the 64 bit converted path
   // if any 64 bit paths were discovered
   if(found64)
     {
     this->SearchPaths = path64;
     }
 }

 //----------------------------------------------------------------------------
 std::string cmFindLibraryCommand::FindLibrary()
 {
   std::string library;
   if(this->SearchFrameworkFirst || this->SearchFrameworkOnly)
     {
     library = this->FindFrameworkLibrary();
     }
   if(library.empty() && !this->SearchFrameworkOnly)
     {
     library = this->FindNormalLibrary();
     }
   if(library.empty() && this->SearchFrameworkLast)
     {
     library = this->FindFrameworkLibrary();
     }
   return library;
 }

 //----------------------------------------------------------------------------
 struct cmFindLibraryHelper
 {
   cmFindLibraryHelper(cmMakefile* mf);

   // Context information.
   cmMakefile* Makefile;
   cmGlobalGenerator* GG;

   // List of valid prefixes and suffixes.
   std::vector<std::string> Prefixes;
   std::vector<std::string> Suffixes;
   std::string PrefixRegexStr;
   std::string SuffixRegexStr;

   // Keep track of the best library file found so far.
   typedef std::vector<std::string>::size_type size_type;
   std::string BestPath;
   size_type BestPrefix;
   size_type BestSuffix;

   // Support for OpenBSD shared library naming: lib<name>.so.<major>.<minor>
   bool OpenBSD;
   unsigned int BestMajor;
   unsigned int BestMinor;

   // Current name under consideration.
   cmsys::RegularExpression NameRegex;
   bool TryRawName;
   std::string RawName;

   // Current full path under consideration.
   std::string TestPath;

   void RegexFromLiteral(std::string& out, std::string const& in);
   void RegexFromList(std::string& out, std::vector<std::string> const& in);
   size_type GetPrefixIndex(std::string const& prefix)
     {
     return cmsys_stl::find(this->Prefixes.begin(), this->Prefixes.end(),
                            prefix) - this->Prefixes.begin();
     }
   size_type GetSuffixIndex(std::string const& suffix)
     {
     return cmsys_stl::find(this->Suffixes.begin(), this->Suffixes.end(),
                            suffix) - this->Suffixes.begin();
     }
   bool HasValidSuffix(std::string const& name);
   void SetName(std::string const& name);
   bool CheckDirectory(std::string const& path);
 };

 //----------------------------------------------------------------------------
 cmFindLibraryHelper::cmFindLibraryHelper(cmMakefile* mf):
   Makefile(mf)
 {
   this->GG = this->Makefile->GetLocalGenerator()->GetGlobalGenerator();

   // Collect the list of library name prefixes/suffixes to try.
   const char* prefixes_list =
     this->Makefile->GetRequiredDefinition("CMAKE_FIND_LIBRARY_PREFIXES");
   const char* suffixes_list =
     this->Makefile->GetRequiredDefinition("CMAKE_FIND_LIBRARY_SUFFIXES");
   cmSystemTools::ExpandListArgument(prefixes_list, this->Prefixes, true);
   cmSystemTools::ExpandListArgument(suffixes_list, this->Suffixes, true);
   this->RegexFromList(this->PrefixRegexStr, this->Prefixes);
   this->RegexFromList(this->SuffixRegexStr, this->Suffixes);

   // Check whether to use OpenBSD-style library version comparisons.
   this->OpenBSD =
     this->Makefile->GetCMakeInstance()
     ->GetPropertyAsBool("FIND_LIBRARY_USE_OPENBSD_VERSIONING");

   this->TryRawName = false;

   // No library file has yet been found.
   this->BestPrefix = this->Prefixes.size();
   this->BestSuffix = this->Suffixes.size();
   this->BestMajor = 0;
   this->BestMinor = 0;
 }

 //----------------------------------------------------------------------------
 void cmFindLibraryHelper::RegexFromLiteral(std::string& out,
                                            std::string const& in)
 {
   for(std::string::const_iterator ci = in.begin(); ci != in.end(); ++ci)
     {
     char ch = *ci;
     if(ch == '[' || ch == ']' || ch == '(' || ch == ')' || ch == '\\' ||
        ch == '.' || ch == '*' || ch == '+' || ch == '?' || ch == '-' ||
        ch == '^' || ch == '$')
       {
       out += "\\";
       }
 #if defined(_WIN32) || defined(__APPLE__)
     out += tolower(ch);
 #else
     out += ch;
 #endif
     }
 }

 //----------------------------------------------------------------------------
 void cmFindLibraryHelper::RegexFromList(std::string& out,
                                         std::vector<std::string> const& in)
 {
   // Surround the list in parens so the '|' does not apply to anything
   // else and the result can be checked after matching.
   out += "(";
   const char* sep = "";
   for(std::vector<std::string>::const_iterator si = in.begin();
       si != in.end(); ++si)
     {
     // Separate from previous item.
     out += sep;
     sep = "|";

     // Append this item.
     this->RegexFromLiteral(out, *si);
     }
   out += ")";
 }

 //----------------------------------------------------------------------------
 bool cmFindLibraryHelper::HasValidSuffix(std::string const& name)
 {
   // Check if the given name ends in a valid library suffix.
   for(std::vector<std::string>::const_iterator si = this->Suffixes.begin();
       si != this->Suffixes.end(); ++si)
     {
     std::string const& suffix = *si;
     if(name.length() > suffix.length() &&
        name.substr(name.size()-suffix.length()) == suffix)
       {
       return true;
       }
     }
   return false;
 }

 //----------------------------------------------------------------------------
 void cmFindLibraryHelper::SetName(std::string const& name)
 {
   // Consider checking the raw name too.
   this->TryRawName = this->HasValidSuffix(name);
   this->RawName = name;

   // Build a regular expression to match library names.
   std::string regex = "^";
   regex += this->PrefixRegexStr;
   this->RegexFromLiteral(regex, name);
   regex += this->SuffixRegexStr;
   if(this->OpenBSD)
     {
     regex += "(\\.[0-9]+\\.[0-9]+)?";
     }
   regex += "$";
   this->NameRegex.compile(regex.c_str());
 }

 //----------------------------------------------------------------------------
 bool cmFindLibraryHelper::CheckDirectory(std::string const& path)
 {
   // If the original library name provided by the user matches one of
   // the suffixes, try it first.  This allows users to search
   // specifically for a static library on some platforms (on MS tools
   // one cannot tell just from the library name whether it is a static
   // library or an import library).
   if(this->TryRawName)
     {
     this->TestPath = path;
     this->TestPath += this->RawName;
     if(cmSystemTools::FileExists(this->TestPath.c_str(), true))
       {
       this->BestPath =
         cmSystemTools::CollapseFullPath(this->TestPath.c_str());
       cmSystemTools::ConvertToUnixSlashes(this->BestPath);
       return true;
       }
     }

   // Search for a file matching the library name regex.
   std::string dir = path;
   cmSystemTools::ConvertToUnixSlashes(dir);
   std::set<cmStdString> const& files = this->GG->GetDirectoryContent(dir);
   for(std::set<cmStdString>::const_iterator fi = files.begin();
       fi != files.end(); ++fi)
     {
     std::string const& origName = *fi;
 #if defined(_WIN32) || defined(__APPLE__)
     std::string testName = cmSystemTools::LowerCase(origName);
 #else
     std::string const& testName = origName;
 #endif
     if(this->NameRegex.find(testName))
       {
       this->TestPath = path;
       this->TestPath += origName;
       if(!cmSystemTools::FileIsDirectory(this->TestPath.c_str()))
         {
         // This is a matching file.  Check if it is better than the
         // best name found so far.  Earlier prefixes are preferred,
         // followed by earlier suffixes.  For OpenBSD, shared library
         // version extensions are compared.
         size_type prefix = this->GetPrefixIndex(this->NameRegex.match(1));
         size_type suffix = this->GetSuffixIndex(this->NameRegex.match(2));
         unsigned int major = 0;
         unsigned int minor = 0;
         if(this->OpenBSD)
           {
           sscanf(this->NameRegex.match(3).c_str(), ".%u.%u", &major, &minor);
           }
         if(this->BestPath.empty() || prefix < this->BestPrefix ||
            (prefix == this->BestPrefix && suffix < this->BestSuffix) ||
            (prefix == this->BestPrefix && suffix == this->BestSuffix &&
             (major > this->BestMajor ||
              (major == this->BestMajor && minor > this->BestMinor))))
           {
           this->BestPath = this->TestPath;
           this->BestPrefix = prefix;
           this->BestSuffix = suffix;
           this->BestMajor = major;
           this->BestMinor = minor;
           }
         }
       }
     }

   // Use the best candidate found in this directory, if any.
   return !this->BestPath.empty();
 }

 //----------------------------------------------------------------------------
 std::string cmFindLibraryCommand::FindNormalLibrary()
 {
   // Search the entire path for each name.
   cmFindLibraryHelper helper(this->Makefile);
   for(std::vector<std::string>::const_iterator ni = this->Names.begin();
       ni != this->Names.end() ; ++ni)
     {
     // Switch to searching for this name.
     std::string const& name = *ni;
     helper.SetName(name);

     // Search every directory.
     for(std::vector<std::string>::const_iterator
           p = this->SearchPaths.begin();
         p != this->SearchPaths.end(); ++p)
       {
       if(helper.CheckDirectory(*p))
         {
         return helper.BestPath;
         }
       }
     }
   // Couldn't find the library.
   return "";
 }

 //----------------------------------------------------------------------------
 std::string cmFindLibraryCommand::FindFrameworkLibrary()
 {
   // Search for a framework of each name in the entire search path.
   for(std::vector<std::string>::const_iterator ni = this->Names.begin();
       ni != this->Names.end() ; ++ni)
     {
     // Search the paths for a framework with this name.
     std::string fwName = *ni;
     fwName += ".framework";
     std::string fwPath = cmSystemTools::FindDirectory(fwName.c_str(),
                                                       this->SearchPaths,
                                                       true);
     if(!fwPath.empty())
       {
       return fwPath;
       }
     }

   // No framework found.
   return "";
 }
	/*============================================================================
	CMake - Cross Platform Makefile Generator
	Copyright 2000-2009 Kitware, Inc., Insight Software Consortium

	Distributed under the OSI-approved BSD License (the "License");
	see accompanying file Copyright.txt for details.

	This software is distributed WITHOUT ANY WARRANTY; without even the
	implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
	See the License for more information.
	============================================================================*/
	#include "cmFindLibraryCommand.h"
	#include "cmCacheManager.h"
	#include <cmsys/Directory.hxx>
	#include <cmsys/stl/algorithm>

	cmFindLibraryCommand::cmFindLibraryCommand()
	{
	cmSystemTools::ReplaceString(this->GenericDocumentation,
	"FIND_XXX", "find_library");
	cmSystemTools::ReplaceString(this->GenericDocumentation,
	"CMAKE_XXX_PATH", "CMAKE_LIBRARY_PATH");
	cmSystemTools::ReplaceString(this->GenericDocumentation,
	"CMAKE_XXX_MAC_PATH",
	"CMAKE_FRAMEWORK_PATH");
	cmSystemTools::ReplaceString(this->GenericDocumentation,
	"CMAKE_SYSTEM_XXX_MAC_PATH",
	"CMAKE_SYSTEM_FRAMEWORK_PATH");
	cmSystemTools::ReplaceString(this->GenericDocumentation,
	"XXX_SYSTEM", "LIB");
	cmSystemTools::ReplaceString(this->GenericDocumentation,
	"CMAKE_SYSTEM_XXX_PATH",
	"CMAKE_SYSTEM_LIBRARY_PATH");
	cmSystemTools::ReplaceString(this->GenericDocumentation,
	"SEARCH_XXX_DESC", "library");
	cmSystemTools::ReplaceString(this->GenericDocumentation,
	"SEARCH_XXX", "library");
	cmSystemTools::ReplaceString(this->GenericDocumentation,
	"XXX_SUBDIR", "lib");
	cmSystemTools::ReplaceString(this->GenericDocumentation,
	"CMAKE_FIND_ROOT_PATH_MODE_XXX",
	"CMAKE_FIND_ROOT_PATH_MODE_LIBRARY");

	this->EnvironmentPath = "LIB";
	this->GenericDocumentation +=
	"\n"
	"If the library found is a framework, then VAR will be set to "
	"the full path to the framework <fullPath>/A.framework. "
	"When a full path to a framework is used as a library, "
	"CMake will use a -framework A, and a -F<fullPath> to "
	"link the framework to the target. ";
	}

	// cmFindLibraryCommand
	bool cmFindLibraryCommand
	::InitialPass(std::vector<std::string> const& argsIn, cmExecutionStatus &)
	{
	this->VariableDocumentation = "Path to a library.";
	this->CMakePathName = "LIBRARY";
	if(!this->ParseArguments(argsIn))
	{
	return false;
	}
	if(this->AlreadyInCache)
	{
	// If the user specifies the entry on the command line without a
	// type we should add the type and docstring but keep the original
	// value.
	if(this->AlreadyInCacheWithoutMetaInfo)
	{
	this->Makefile->AddCacheDefinition(this->VariableName.c_str(), "",
	this->VariableDocumentation.c_str(),
	cmCacheManager::FILEPATH);
	}
	return true;
	}

	if(const char* abi_name =
	this->Makefile->GetDefinition("CMAKE_INTERNAL_PLATFORM_ABI"))
	{
	std::string abi = abi_name;
	if(abi.find("ELF N32") != abi.npos)
	{
	// Convert lib to lib32.
	this->AddArchitecturePaths("32");
	}
	}

	if(this->Makefile->GetCMakeInstance()
	->GetPropertyAsBool("FIND_LIBRARY_USE_LIB64_PATHS"))
	{
	// add special 64 bit paths if this is a 64 bit compile.
	this->AddLib64Paths();
	}

	std::string library = this->FindLibrary();
	if(library != "")
	{
	// Save the value in the cache
	this->Makefile->AddCacheDefinition(this->VariableName.c_str(),
	library.c_str(),
	this->VariableDocumentation.c_str(),
	cmCacheManager::FILEPATH);
	return true;
	}
	std::string notfound = this->VariableName + "-NOTFOUND";
	this->Makefile->AddCacheDefinition(this->VariableName.c_str(),
	notfound.c_str(),
	this->VariableDocumentation.c_str(),
	cmCacheManager::FILEPATH);
	return true;
	}

	//----------------------------------------------------------------------------
	void cmFindLibraryCommand::AddArchitecturePaths(const char* suffix)
	{
	std::vector<std::string> newPaths;
	bool found = false;
	std::string subpath = "lib";
	subpath += suffix;
	subpath += "/";
	for(std::vector<std::string>::iterator i = this->SearchPaths.begin();
	i != this->SearchPaths.end(); ++i)
	{
	// Try replacing lib/ with lib<suffix>/
	std::string s = *i;
	cmSystemTools::ReplaceString(s, "lib/", subpath.c_str());
	if((s != *i) && cmSystemTools::FileIsDirectory(s.c_str()))
	{
	found = true;
	newPaths.push_back(s);
	}

	// Now look for lib<suffix>
	s = *i;
	s += suffix;
	if(cmSystemTools::FileIsDirectory(s.c_str()))
	{
	found = true;
	newPaths.push_back(s);
	}
	// now add the original unchanged path
	if(cmSystemTools::FileIsDirectory(i->c_str()))
	{
	newPaths.push_back(*i);
	}
	}

	// If any new paths were found replace the original set.
	if(found)
	{
	this->SearchPaths = newPaths;
	}
	}

	void cmFindLibraryCommand::AddLib64Paths()
	{
	if(!this->Makefile->GetLocalGenerator()->GetGlobalGenerator()->
	GetLanguageEnabled("C"))
	{
	return;
	}
	std::string voidsize =
	this->Makefile->GetSafeDefinition("CMAKE_SIZEOF_VOID_P");
	int size = atoi(voidsize.c_str());
	if(size != 8)
	{
	return;
	}
	std::vector<std::string> path64;
	bool found64 = false;
	for(std::vector<std::string>::iterator i = this->SearchPaths.begin();
	i != this->SearchPaths.end(); ++i)
	{
	std::string s = *i;
	std::string s2 = *i;
	cmSystemTools::ReplaceString(s, "lib/", "lib64/");
	// try to replace lib with lib64 and see if it is there,
	// then prepend it to the path
	// Note that all paths have trailing slashes.
	if((s != *i) && cmSystemTools::FileIsDirectory(s.c_str()))
	{
	path64.push_back(s);
	found64 = true;
	}
	// now just add a 64 to the path name and if it is there,
	// add it to the path
	s2 += "64/";
	if(cmSystemTools::FileIsDirectory(s2.c_str()))
	{
	found64 = true;
	path64.push_back(s2);
	}
	// now add the original unchanged path
	if(cmSystemTools::FileIsDirectory(i->c_str()))
	{
	path64.push_back(*i);
	}
	}
	// now replace the SearchPaths with the 64 bit converted path
	// if any 64 bit paths were discovered
	if(found64)
	{
	this->SearchPaths = path64;
	}
	}

	//----------------------------------------------------------------------------
	std::string cmFindLibraryCommand::FindLibrary()
	{
	std::string library;
	if(this->SearchFrameworkFirst \|\| this->SearchFrameworkOnly)
	{
	library = this->FindFrameworkLibrary();
	}
	if(library.empty() && !this->SearchFrameworkOnly)
	{
	library = this->FindNormalLibrary();
	}
	if(library.empty() && this->SearchFrameworkLast)
	{
	library = this->FindFrameworkLibrary();
	}
	return library;
	}

	//----------------------------------------------------------------------------
	struct cmFindLibraryHelper
	{
	cmFindLibraryHelper(cmMakefile* mf);

	// Context information.
	cmMakefile* Makefile;
	cmGlobalGenerator* GG;

	// List of valid prefixes and suffixes.
	std::vector<std::string> Prefixes;
	std::vector<std::string> Suffixes;
	std::string PrefixRegexStr;
	std::string SuffixRegexStr;

	// Keep track of the best library file found so far.
	typedef std::vector<std::string>::size_type size_type;
	std::string BestPath;
	size_type BestPrefix;
	size_type BestSuffix;

	// Support for OpenBSD shared library naming: lib<name>.so.<major>.<minor>
	bool OpenBSD;
	unsigned int BestMajor;
	unsigned int BestMinor;

	// Current name under consideration.
	cmsys::RegularExpression NameRegex;
	bool TryRawName;
	std::string RawName;

	// Current full path under consideration.
	std::string TestPath;

	void RegexFromLiteral(std::string& out, std::string const& in);
	void RegexFromList(std::string& out, std::vector<std::string> const& in);
	size_type GetPrefixIndex(std::string const& prefix)
	{
	return cmsys_stl::find(this->Prefixes.begin(), this->Prefixes.end(),
	prefix) - this->Prefixes.begin();
	}
	size_type GetSuffixIndex(std::string const& suffix)
	{
	return cmsys_stl::find(this->Suffixes.begin(), this->Suffixes.end(),
	suffix) - this->Suffixes.begin();
	}
	bool HasValidSuffix(std::string const& name);
	void SetName(std::string const& name);
	bool CheckDirectory(std::string const& path);
	};

	//----------------------------------------------------------------------------
	cmFindLibraryHelper::cmFindLibraryHelper(cmMakefile* mf):
	Makefile(mf)
	{
	this->GG = this->Makefile->GetLocalGenerator()->GetGlobalGenerator();

	// Collect the list of library name prefixes/suffixes to try.
	const char* prefixes_list =
	this->Makefile->GetRequiredDefinition("CMAKE_FIND_LIBRARY_PREFIXES");
	const char* suffixes_list =
	this->Makefile->GetRequiredDefinition("CMAKE_FIND_LIBRARY_SUFFIXES");
	cmSystemTools::ExpandListArgument(prefixes_list, this->Prefixes, true);
	cmSystemTools::ExpandListArgument(suffixes_list, this->Suffixes, true);
	this->RegexFromList(this->PrefixRegexStr, this->Prefixes);
	this->RegexFromList(this->SuffixRegexStr, this->Suffixes);

	// Check whether to use OpenBSD-style library version comparisons.
	this->OpenBSD =
	this->Makefile->GetCMakeInstance()
	->GetPropertyAsBool("FIND_LIBRARY_USE_OPENBSD_VERSIONING");

	this->TryRawName = false;

	// No library file has yet been found.
	this->BestPrefix = this->Prefixes.size();
	this->BestSuffix = this->Suffixes.size();
	this->BestMajor = 0;
	this->BestMinor = 0;
	}

	//----------------------------------------------------------------------------
	void cmFindLibraryHelper::RegexFromLiteral(std::string& out,
	std::string const& in)
	{
	for(std::string::const_iterator ci = in.begin(); ci != in.end(); ++ci)
	{
	char ch = *ci;
	if(ch == '[' \|\| ch == ']' \|\| ch == '(' \|\| ch == ')' \|\| ch == '\\' \|\|
	ch == '.' \|\| ch == '*' \|\| ch == '+' \|\| ch == '?' \|\| ch == '-' \|\|
	ch == '^' \|\| ch == '$')
	{
	out += "\\";
	}
	#if defined(_WIN32) \|\| defined(__APPLE__)
	out += tolower(ch);
	#else
	out += ch;
	#endif
	}
	}

	//----------------------------------------------------------------------------
	void cmFindLibraryHelper::RegexFromList(std::string& out,
	std::vector<std::string> const& in)
	{
	// Surround the list in parens so the '\|' does not apply to anything
	// else and the result can be checked after matching.
	out += "(";
	const char* sep = "";
	for(std::vector<std::string>::const_iterator si = in.begin();
	si != in.end(); ++si)
	{
	// Separate from previous item.
	out += sep;
	sep = "\|";

	// Append this item.
	this->RegexFromLiteral(out, *si);
	}
	out += ")";
	}

	//----------------------------------------------------------------------------
	bool cmFindLibraryHelper::HasValidSuffix(std::string const& name)
	{
	// Check if the given name ends in a valid library suffix.
	for(std::vector<std::string>::const_iterator si = this->Suffixes.begin();
	si != this->Suffixes.end(); ++si)
	{
	std::string const& suffix = *si;
	if(name.length() > suffix.length() &&
	name.substr(name.size()-suffix.length()) == suffix)
	{
	return true;
	}
	}
	return false;
	}

	//----------------------------------------------------------------------------
	void cmFindLibraryHelper::SetName(std::string const& name)
	{
	// Consider checking the raw name too.
	this->TryRawName = this->HasValidSuffix(name);
	this->RawName = name;

	// Build a regular expression to match library names.
	std::string regex = "^";
	regex += this->PrefixRegexStr;
	this->RegexFromLiteral(regex, name);
	regex += this->SuffixRegexStr;
	if(this->OpenBSD)
	{
	regex += "(\\.[0-9]+\\.[0-9]+)?";
	}
	regex += "$";
	this->NameRegex.compile(regex.c_str());
	}

	//----------------------------------------------------------------------------
	bool cmFindLibraryHelper::CheckDirectory(std::string const& path)
	{
	// If the original library name provided by the user matches one of
	// the suffixes, try it first. This allows users to search
	// specifically for a static library on some platforms (on MS tools
	// one cannot tell just from the library name whether it is a static
	// library or an import library).
	if(this->TryRawName)
	{
	this->TestPath = path;
	this->TestPath += this->RawName;
	if(cmSystemTools::FileExists(this->TestPath.c_str(), true))
	{
	this->BestPath =
	cmSystemTools::CollapseFullPath(this->TestPath.c_str());
	cmSystemTools::ConvertToUnixSlashes(this->BestPath);
	return true;
	}
	}

	// Search for a file matching the library name regex.
	std::string dir = path;
	cmSystemTools::ConvertToUnixSlashes(dir);
	std::set<cmStdString> const& files = this->GG->GetDirectoryContent(dir);
	for(std::set<cmStdString>::const_iterator fi = files.begin();
	fi != files.end(); ++fi)
	{
	std::string const& origName = *fi;
	#if defined(_WIN32) \|\| defined(__APPLE__)
	std::string testName = cmSystemTools::LowerCase(origName);
	#else
	std::string const& testName = origName;
	#endif
	if(this->NameRegex.find(testName))
	{
	this->TestPath = path;
	this->TestPath += origName;
	if(!cmSystemTools::FileIsDirectory(this->TestPath.c_str()))
	{
	// This is a matching file. Check if it is better than the
	// best name found so far. Earlier prefixes are preferred,
	// followed by earlier suffixes. For OpenBSD, shared library
	// version extensions are compared.
	size_type prefix = this->GetPrefixIndex(this->NameRegex.match(1));
	size_type suffix = this->GetSuffixIndex(this->NameRegex.match(2));
	unsigned int major = 0;
	unsigned int minor = 0;
	if(this->OpenBSD)
	{
	sscanf(this->NameRegex.match(3).c_str(), ".%u.%u", &major, &minor);
	}
	if(this->BestPath.empty() \|\| prefix < this->BestPrefix \|\|
	(prefix == this->BestPrefix && suffix < this->BestSuffix) \|\|
	(prefix == this->BestPrefix && suffix == this->BestSuffix &&
	(major > this->BestMajor \|\|
	(major == this->BestMajor && minor > this->BestMinor))))
	{
	this->BestPath = this->TestPath;
	this->BestPrefix = prefix;
	this->BestSuffix = suffix;
	this->BestMajor = major;
	this->BestMinor = minor;
	}
	}
	}
	}

	// Use the best candidate found in this directory, if any.
	return !this->BestPath.empty();
	}

	//----------------------------------------------------------------------------
	std::string cmFindLibraryCommand::FindNormalLibrary()
	{
	// Search the entire path for each name.
	cmFindLibraryHelper helper(this->Makefile);
	for(std::vector<std::string>::const_iterator ni = this->Names.begin();
	ni != this->Names.end() ; ++ni)
	{
	// Switch to searching for this name.
	std::string const& name = *ni;
	helper.SetName(name);

	// Search every directory.
	for(std::vector<std::string>::const_iterator
	p = this->SearchPaths.begin();
	p != this->SearchPaths.end(); ++p)
	{
	if(helper.CheckDirectory(*p))
	{
	return helper.BestPath;
	}
	}
	}
	// Couldn't find the library.
	return "";
	}

	//----------------------------------------------------------------------------
	std::string cmFindLibraryCommand::FindFrameworkLibrary()
	{
	// Search for a framework of each name in the entire search path.
	for(std::vector<std::string>::const_iterator ni = this->Names.begin();
	ni != this->Names.end() ; ++ni)
	{
	// Search the paths for a framework with this name.
	std::string fwName = *ni;
	fwName += ".framework";
	std::string fwPath = cmSystemTools::FindDirectory(fwName.c_str(),
	this->SearchPaths,
	true);
	if(!fwPath.empty())
	{
	return fwPath;
	}
	}

	// No framework found.
	return "";
	}