src/parsec/disk-image/parsec/parsec-benchmark/pkgs/tools/cmake/src/Source/cmFindBase.cxx - public/gem5-resources - Git at Google

 /*=========================================================================

   Program:   CMake - Cross-Platform Makefile Generator
   Module:    $RCSfile: cmFindBase.cxx,v $
   Language:  C++
   Date:      $Date: 2012/03/29 17:21:09 $
   Version:   $Revision: 1.1.1.1 $

   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.

      This software is distributed WITHOUT ANY WARRANTY; without even
      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
      PURPOSE.  See the above copyright notices for more information.

 =========================================================================*/
 #include "cmFindBase.h"

 cmFindBase::cmFindBase()
 {
   cmSystemTools::ReplaceString(this->GenericDocumentationPathsOrder,
                                "FIND_ARGS_XXX", "<VAR> NAMES name");
   this->AlreadyInCache = false;
   this->AlreadyInCacheWithoutMetaInfo = false;
   this->GenericDocumentation =
     "   FIND_XXX(<VAR> name1 [path1 path2 ...])\n"
     "This is the short-hand signature for the command that "
     "is sufficient in many cases.  It is the same "
     "as FIND_XXX(<VAR> name1 [PATHS path1 path2 ...])\n"
     "   FIND_XXX(\n"
     "             <VAR>\n"
     "             name | NAMES name1 [name2 ...]\n"
     "             [HINTS path1 [path2 ... ENV var]]\n"
     "             [PATHS path1 [path2 ... ENV var]]\n"
     "             [PATH_SUFFIXES suffix1 [suffix2 ...]]\n"
     "             [DOC \"cache documentation string\"]\n"
     "             [NO_DEFAULT_PATH]\n"
     "             [NO_CMAKE_ENVIRONMENT_PATH]\n"
     "             [NO_CMAKE_PATH]\n"
     "             [NO_SYSTEM_ENVIRONMENT_PATH]\n"
     "             [NO_CMAKE_SYSTEM_PATH]\n"
     "             [CMAKE_FIND_ROOT_PATH_BOTH |\n"
     "              ONLY_CMAKE_FIND_ROOT_PATH |\n"
     "              NO_CMAKE_FIND_ROOT_PATH]\n"
     "            )\n"
     ""
     "This command is used to find a SEARCH_XXX_DESC. "
     "A cache entry named by <VAR> is created to store the result "
     "of this command.  "
     "If the SEARCH_XXX is found the result is stored in the variable "
     "and the search will not be repeated unless the variable is cleared.  "
     "If nothing is found, the result will be "
     "<VAR>-NOTFOUND, and the search will be attempted again the "
     "next time FIND_XXX is invoked with the same variable.  "
     "The name of the SEARCH_XXX that "
     "is searched for is specified by the names listed "
     "after the NAMES argument.   Additional search locations "
     "can be specified after the PATHS argument.  If ENV var is "
     "found in the HINTS or PATHS section the environment variable var "
     "will be read and converted from a system environment variable to "
     "a cmake style list of paths.  For example ENV PATH would be a way "
     "to list the system path variable. The argument "
     "after DOC will be used for the documentation string in "
     "the cache.  PATH_SUFFIXES can be used to give sub directories "
     "that will be appended to the search paths.\n"
     "If NO_DEFAULT_PATH is specified, then no additional paths are "
     "added to the search. "
     "If NO_DEFAULT_PATH is not specified, the search process is as follows:\n"
     "1. Search paths specified in cmake-specific cache variables.  "
     "These are intended to be used on the command line with a -DVAR=value.  "
     "This can be skipped if NO_CMAKE_PATH is passed.\n"
     "   <prefix>/XXX_SUBDIR for each <prefix> in CMAKE_PREFIX_PATH\n"
     "   CMAKE_XXX_PATH\n"
     "   CMAKE_XXX_MAC_PATH\n"
     "2. Search paths specified in cmake-specific environment variables.  "
     "These are intended to be set in the user's shell configuration.  "
     "This can be skipped if NO_CMAKE_ENVIRONMENT_PATH is passed.\n"
     "   <prefix>/XXX_SUBDIR for each <prefix> in CMAKE_PREFIX_PATH\n"
     "   CMAKE_XXX_PATH\n"
     "   CMAKE_XXX_MAC_PATH\n"
     "3. Search the paths specified by the HINTS option.  "
     "These should be paths computed by system introspection, such as a "
     "hint provided by the location of another item already found.  "
     "Hard-coded guesses should be specified with the PATHS option.\n"
     "4. Search the standard system environment variables. "
     "This can be skipped if NO_SYSTEM_ENVIRONMENT_PATH is an argument.\n"
     "   PATH\n"
     "   XXX_SYSTEM\n"  // replace with "", LIB, or INCLUDE
     "5. Search cmake variables defined in the Platform files "
     "for the current system.  This can be skipped if NO_CMAKE_SYSTEM_PATH "
     "is passed.\n"
     "   <prefix>/XXX_SUBDIR for each <prefix> in CMAKE_SYSTEM_PREFIX_PATH\n"
     "   CMAKE_SYSTEM_XXX_PATH\n"
     "   CMAKE_SYSTEM_XXX_MAC_PATH\n"
     "6. Search the paths specified by the PATHS option "
     "or in the short-hand version of the command.  "
     "These are typically hard-coded guesses.\n"
     ;
   this->GenericDocumentation += this->GenericDocumentationMacPolicy;
   this->GenericDocumentation += this->GenericDocumentationRootPath;
   this->GenericDocumentation += this->GenericDocumentationPathsOrder;
 }

 bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
 {
   if(argsIn.size() < 2 )
     {
     this->SetError("called with incorrect number of arguments");
     return false;
     }

   // CMake versions below 2.3 did not search all these extra
   // locations.  Preserve compatibility unless a modern argument is
   // passed.
   bool compatibility = this->Makefile->NeedBackwardsCompatibility(2,3);

   // copy argsIn into args so it can be modified,
   // in the process extract the DOC "documentation"
   size_t size = argsIn.size();
   std::vector<std::string> args;
   bool foundDoc = false;
   for(unsigned int j = 0; j < size; ++j)
     {
     if(foundDoc  || argsIn[j] != "DOC" )
       {
       if(argsIn[j] == "ENV")
         {
         if(j+1 < size)
           {
           j++;
           cmSystemTools::GetPath(args, argsIn[j].c_str());
           }
         }
       else
         {
         args.push_back(argsIn[j]);
         }
       }
     else
       {
       if(j+1 < size)
         {
         foundDoc = true;
         this->VariableDocumentation = argsIn[j+1];
         j++;
         if(j >= size)
           {
           break;
           }
         }
       }
     }
   this->VariableName = args[0];
   if(this->CheckForVariableInCache())
     {
     this->AlreadyInCache = true;
     return true;
     }
   this->AlreadyInCache = false;

   // Find the current root path mode.
   this->SelectDefaultRootPathMode();

   // Find the current bundle/framework search policy.
   this->SelectDefaultMacMode();

   bool newStyle = false;
   enum Doing { DoingNone, DoingNames, DoingPaths, DoingPathSuffixes,
                DoingHints };
   Doing doing = DoingNames; // assume it starts with a name
   for (unsigned int j = 1; j < args.size(); ++j)
     {
     if(args[j] == "NAMES")
       {
       doing = DoingNames;
       newStyle = true;
       }
     else if (args[j] == "PATHS")
       {
       doing = DoingPaths;
       newStyle = true;
       }
     else if (args[j] == "HINTS")
       {
       doing = DoingHints;
       newStyle = true;
       }
     else if (args[j] == "PATH_SUFFIXES")
       {
       doing = DoingPathSuffixes;
       compatibility = false;
       newStyle = true;
       }
     else if (args[j] == "NO_SYSTEM_PATH")
       {
       doing = DoingNone;
       this->NoDefaultPath = true;
       }
     else if (this->CheckCommonArgument(args[j]))
       {
       doing = DoingNone;
       compatibility = false;
       // Some common arguments were accidentally supported by CMake
       // 2.4 and 2.6.0 in the short-hand form of the command, so we
       // must support it even though it is not documented.
       }
     else if(doing == DoingNames)
       {
       this->Names.push_back(args[j]);
       }
     else if(doing == DoingPaths)
       {
       this->AddUserPath(args[j], this->UserPaths);
       }
     else if(doing == DoingHints)
       {
       this->AddUserPath(args[j], this->UserHints);
       }
     else if(doing == DoingPathSuffixes)
       {
       this->AddPathSuffix(args[j]);
       }
     }

   // Now that arguments have been parsed check the compatibility
   // setting.  If we need to be compatible with CMake 2.2 and earlier
   // do not add the CMake system paths.  It is safe to add the CMake
   // environment paths and system environment paths because that
   // existed in 2.2.  It is safe to add the CMake user variable paths
   // because the user or project has explicitly set them.
   if(compatibility)
     {
     this->NoCMakeSystemPath = true;
     }

   if(this->VariableDocumentation.size() == 0)
     {
     this->VariableDocumentation = "Where can ";
     if(this->Names.size() == 0)
       {
       this->VariableDocumentation += "the (unknown) library be found";
       }
     else if(this->Names.size() == 1)
       {
       this->VariableDocumentation += "the "
         + this->Names[0] + " library be found";
       }
     else
       {
       this->VariableDocumentation += "one of the " + this->Names[0];
       for (unsigned int j = 1; j < this->Names.size() - 1; ++j)
         {
         this->VariableDocumentation += ", " + this->Names[j];
         }
       this->VariableDocumentation += " or "
         + this->Names[this->Names.size() - 1] + " libraries be found";
       }
     }

   // look for old style
   // FIND_*(VAR name path1 path2 ...)
   if(!newStyle)
     {
     // All the short-hand arguments have been recorded as names.
     std::vector<std::string> shortArgs = this->Names;
     this->Names.clear(); // clear out any values in Names
     this->Names.push_back(shortArgs[0]);
     for(unsigned int j = 1; j < shortArgs.size(); ++j)
       {
       this->AddUserPath(shortArgs[j], this->UserPaths);
       }
     }
   this->ExpandPaths();

   // Handle search root stuff.
   this->RerootPaths(this->SearchPaths);

   // Add a trailing slash to all prefixes to aid the search process.
   this->AddTrailingSlashes(this->SearchPaths);

   return true;
 }

 void cmFindBase::ExpandPaths()
 {
   this->AddCMakeVariablePath();
   this->AddCMakeEnvironmentPath();
   this->AddUserHintsPath();
   this->AddSystemEnvironmentPath();
   this->AddCMakeSystemVariablePath();
   this->AddUserGuessPath();

   // Add suffixes and clean up paths.
   this->AddPathSuffixes();
 }

 //----------------------------------------------------------------------------
 void cmFindBase::AddPrefixPaths(std::vector<std::string> const& in_paths,
                                 PathType pathType)
 {
   // default for programs
   std::string subdir = "bin";

   if (this->CMakePathName == "INCLUDE")
     {
     subdir = "include";
     }
   else if (this->CMakePathName == "LIBRARY")
     {
     subdir = "lib";
     }
   else if (this->CMakePathName == "FRAMEWORK")
     {
     subdir = "";  // ? what to do for frameworks ?
     }

   for(std::vector<std::string>::const_iterator it = in_paths.begin();
       it != in_paths.end(); ++it)
     {
     std::string dir = it->c_str();
     if(!subdir.empty() && !dir.empty() && dir[dir.size()-1] != '/')
       {
       dir += "/";
       }
     std::string add = dir + subdir;
     if(add != "/")
       {
       this->AddPathInternal(add, pathType);
       }
     if (subdir == "bin")
       {
       this->AddPathInternal(dir+"sbin", pathType);
       }
     if(!subdir.empty() && *it != "/")
       {
       this->AddPathInternal(*it, pathType);
       }
     }
 }

 //----------------------------------------------------------------------------
 void cmFindBase::AddCMakePrefixPath(const char* variable)
 {
   // Get a path from a CMake variable.
   if(const char* varPath = this->Makefile->GetDefinition(variable))
     {
     std::vector<std::string> tmp;
     cmSystemTools::ExpandListArgument(varPath, tmp);
     this->AddPrefixPaths(tmp, CMakePath);
     }
 }

 //----------------------------------------------------------------------------
 void cmFindBase::AddEnvPrefixPath(const char* variable)
 {
   // Get a path from the environment.
   std::vector<std::string> tmp;
   cmSystemTools::GetPath(tmp, variable);
   this->AddPrefixPaths(tmp, EnvPath);
 }

 //----------------------------------------------------------------------------
 void cmFindBase::AddCMakeEnvironmentPath()
 {
   if(!this->NoCMakeEnvironmentPath && !this->NoDefaultPath)
     {
     // Add CMAKE_*_PATH environment variables
     std::string var = "CMAKE_";
     var += this->CMakePathName;
     var += "_PATH";
     this->AddEnvPrefixPath("CMAKE_PREFIX_PATH");
     this->AddEnvPath(var.c_str());

     if(this->CMakePathName == "PROGRAM")
       {
       this->AddEnvPath("CMAKE_APPBUNDLE_PATH");
       }
     else
       {
       this->AddEnvPath("CMAKE_FRAMEWORK_PATH");
       }
     }
 }

 //----------------------------------------------------------------------------
 void cmFindBase::AddCMakeVariablePath()
 {
   if(!this->NoCMakePath && !this->NoDefaultPath)
     {
     // Add CMake varibles of the same name as the previous environment
     // varibles CMAKE_*_PATH to be used most of the time with -D
     // command line options
     std::string var = "CMAKE_";
     var += this->CMakePathName;
     var += "_PATH";
     this->AddCMakePrefixPath("CMAKE_PREFIX_PATH");
     this->AddCMakePath(var.c_str());

     if(this->CMakePathName == "PROGRAM")
       {
       this->AddCMakePath("CMAKE_APPBUNDLE_PATH");
       }
     else
       {
       this->AddCMakePath("CMAKE_FRAMEWORK_PATH");
       }
     }
 }

 //----------------------------------------------------------------------------
 void cmFindBase::AddSystemEnvironmentPath()
 {
   if(!this->NoSystemEnvironmentPath && !this->NoDefaultPath)
     {
     // Add LIB or INCLUDE
     if(!this->EnvironmentPath.empty())
       {
       this->AddEnvPath(this->EnvironmentPath.c_str());
       }
     // Add PATH
     this->AddEnvPath(0);
     }
 }

 //----------------------------------------------------------------------------
 void cmFindBase::AddCMakeSystemVariablePath()
 {
   if(!this->NoCMakeSystemPath && !this->NoDefaultPath)
     {
     std::string var = "CMAKE_SYSTEM_";
     var += this->CMakePathName;
     var += "_PATH";
     this->AddCMakePrefixPath("CMAKE_SYSTEM_PREFIX_PATH");
     this->AddCMakePath(var.c_str());

     if(this->CMakePathName == "PROGRAM")
       {
       this->AddCMakePath("CMAKE_SYSTEM_APPBUNDLE_PATH");
       }
     else
       {
       this->AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH");
       }
     }
 }

 //----------------------------------------------------------------------------
 void cmFindBase::AddUserHintsPath()
 {
   this->AddPathsInternal(this->UserHints, CMakePath);
 }

 //----------------------------------------------------------------------------
 void cmFindBase::AddUserGuessPath()
 {
   this->AddPathsInternal(this->UserPaths, CMakePath);
 }

 //----------------------------------------------------------------------------
 void cmFindBase::AddPathSuffixes()
 {
   std::vector<std::string>& paths = this->SearchPaths;
   std::vector<std::string> finalPath = paths;
   std::vector<std::string>::iterator i;
   // clear the path
   paths.clear();
   // convert all paths to unix slashes and add search path suffixes
   // if there are any
   for(i = finalPath.begin();
       i != finalPath.end(); ++i)
     {
     cmSystemTools::ConvertToUnixSlashes(*i);
     // copy each finalPath combined with SearchPathSuffixes
     // to the SearchPaths ivar
     for(std::vector<std::string>::iterator j =
           this->SearchPathSuffixes.begin();
         j != this->SearchPathSuffixes.end(); ++j)
       {
       // if *i is only / then do not add a //
       // this will get incorrectly considered a network
       // path on windows and cause huge delays.
       std::string p = *i;
       if(p.size() && p[p.size()-1] != '/')
         {
         p += std::string("/");
         }
       p +=  *j;
       // add to all paths because the search path may be modified
       // later with lib being replaced for lib64 which may exist
       paths.push_back(p);
       }
     }
   // now put the path without the path suffixes in the SearchPaths
   for(i = finalPath.begin();
       i != finalPath.end(); ++i)
     {
     // put all search paths in because it may later be replaced
     // by lib64 stuff fixes bug 4009
     paths.push_back(*i);
     }
 }

 void cmFindBase::PrintFindStuff()
 {
   std::cerr << "SearchFrameworkLast: " << this->SearchFrameworkLast << "\n";
   std::cerr << "SearchFrameworkOnly: " << this->SearchFrameworkOnly << "\n";
   std::cerr << "SearchFrameworkFirst: " << this->SearchFrameworkFirst << "\n";
   std::cerr << "SearchAppBundleLast: " << this->SearchAppBundleLast << "\n";
   std::cerr << "SearchAppBundleOnly: " << this->SearchAppBundleOnly << "\n";
   std::cerr << "SearchAppBundleFirst: " << this->SearchAppBundleFirst << "\n";
   std::cerr << "VariableName " << this->VariableName << "\n";
   std::cerr << "VariableDocumentation "
             << this->VariableDocumentation << "\n";
   std::cerr << "NoDefaultPath " << this->NoDefaultPath << "\n";
   std::cerr << "NoCMakeEnvironmentPath "
             << this->NoCMakeEnvironmentPath << "\n";
   std::cerr << "NoCMakePath " << this->NoCMakePath << "\n";
   std::cerr << "NoSystemEnvironmentPath "
             << this->NoSystemEnvironmentPath << "\n";
   std::cerr << "NoCMakeSystemPath " << this->NoCMakeSystemPath << "\n";
   std::cerr << "EnvironmentPath " << this->EnvironmentPath << "\n";
   std::cerr << "CMakePathName " << this->CMakePathName << "\n";
   std::cerr << "Names  ";
   for(unsigned int i =0; i < this->Names.size(); ++i)
     {
     std::cerr << this->Names[i] << " ";
     }
   std::cerr << "\n";
   std::cerr << "\n";
   std::cerr << "SearchPathSuffixes  ";
   for(unsigned int i =0; i < this->SearchPathSuffixes.size(); ++i)
     {
     std::cerr << this->SearchPathSuffixes[i] << "\n";
     }
   std::cerr << "\n";
   std::cerr << "SearchPaths\n";
   for(unsigned int i =0; i < this->SearchPaths.size(); ++i)
     {
     std::cerr << "[" << this->SearchPaths[i] << "]\n";
     }
 }

 bool cmFindBase::CheckForVariableInCache()
 {
   if(const char* cacheValue =
      this->Makefile->GetDefinition(this->VariableName.c_str()))
     {
     cmCacheManager::CacheIterator it =
       this->Makefile->GetCacheManager()->
       GetCacheIterator(this->VariableName.c_str());
     bool found = !cmSystemTools::IsNOTFOUND(cacheValue);
     bool cached = !it.IsAtEnd();
     if(found)
       {
       // 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.  Tell the subclass implementations to do
       // this.
       if(cached && it.GetType() == cmCacheManager::UNINITIALIZED)
         {
         this->AlreadyInCacheWithoutMetaInfo = true;
         }
       return true;
       }
     else if(cached)
       {
       const char* hs = it.GetProperty("HELPSTRING");
       this->VariableDocumentation = hs?hs:"(none)";
       }
     }
   return false;
 }
	/*=========================================================================

	Program: CMake - Cross-Platform Makefile Generator
	Module: $RCSfile: cmFindBase.cxx,v $
	Language: C++
	Date: $Date: 2012/03/29 17:21:09 $
	Version: $Revision: 1.1.1.1 $

	Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
	See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.

	This software is distributed WITHOUT ANY WARRANTY; without even
	the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
	PURPOSE. See the above copyright notices for more information.

	=========================================================================*/
	#include "cmFindBase.h"

	cmFindBase::cmFindBase()
	{
	cmSystemTools::ReplaceString(this->GenericDocumentationPathsOrder,
	"FIND_ARGS_XXX", "<VAR> NAMES name");
	this->AlreadyInCache = false;
	this->AlreadyInCacheWithoutMetaInfo = false;
	this->GenericDocumentation =
	" FIND_XXX(<VAR> name1 [path1 path2 ...])\n"
	"This is the short-hand signature for the command that "
	"is sufficient in many cases. It is the same "
	"as FIND_XXX(<VAR> name1 [PATHS path1 path2 ...])\n"
	" FIND_XXX(\n"
	" <VAR>\n"
	" name \| NAMES name1 [name2 ...]\n"
	" [HINTS path1 [path2 ... ENV var]]\n"
	" [PATHS path1 [path2 ... ENV var]]\n"
	" [PATH_SUFFIXES suffix1 [suffix2 ...]]\n"
	" [DOC \"cache documentation string\"]\n"
	" [NO_DEFAULT_PATH]\n"
	" [NO_CMAKE_ENVIRONMENT_PATH]\n"
	" [NO_CMAKE_PATH]\n"
	" [NO_SYSTEM_ENVIRONMENT_PATH]\n"
	" [NO_CMAKE_SYSTEM_PATH]\n"
	" [CMAKE_FIND_ROOT_PATH_BOTH \|\n"
	" ONLY_CMAKE_FIND_ROOT_PATH \|\n"
	" NO_CMAKE_FIND_ROOT_PATH]\n"
	" )\n"
	""
	"This command is used to find a SEARCH_XXX_DESC. "
	"A cache entry named by <VAR> is created to store the result "
	"of this command. "
	"If the SEARCH_XXX is found the result is stored in the variable "
	"and the search will not be repeated unless the variable is cleared. "
	"If nothing is found, the result will be "
	"<VAR>-NOTFOUND, and the search will be attempted again the "
	"next time FIND_XXX is invoked with the same variable. "
	"The name of the SEARCH_XXX that "
	"is searched for is specified by the names listed "
	"after the NAMES argument. Additional search locations "
	"can be specified after the PATHS argument. If ENV var is "
	"found in the HINTS or PATHS section the environment variable var "
	"will be read and converted from a system environment variable to "
	"a cmake style list of paths. For example ENV PATH would be a way "
	"to list the system path variable. The argument "
	"after DOC will be used for the documentation string in "
	"the cache. PATH_SUFFIXES can be used to give sub directories "
	"that will be appended to the search paths.\n"
	"If NO_DEFAULT_PATH is specified, then no additional paths are "
	"added to the search. "
	"If NO_DEFAULT_PATH is not specified, the search process is as follows:\n"
	"1. Search paths specified in cmake-specific cache variables. "
	"These are intended to be used on the command line with a -DVAR=value. "
	"This can be skipped if NO_CMAKE_PATH is passed.\n"
	" <prefix>/XXX_SUBDIR for each <prefix> in CMAKE_PREFIX_PATH\n"
	" CMAKE_XXX_PATH\n"
	" CMAKE_XXX_MAC_PATH\n"
	"2. Search paths specified in cmake-specific environment variables. "
	"These are intended to be set in the user's shell configuration. "
	"This can be skipped if NO_CMAKE_ENVIRONMENT_PATH is passed.\n"
	" <prefix>/XXX_SUBDIR for each <prefix> in CMAKE_PREFIX_PATH\n"
	" CMAKE_XXX_PATH\n"
	" CMAKE_XXX_MAC_PATH\n"
	"3. Search the paths specified by the HINTS option. "
	"These should be paths computed by system introspection, such as a "
	"hint provided by the location of another item already found. "
	"Hard-coded guesses should be specified with the PATHS option.\n"
	"4. Search the standard system environment variables. "
	"This can be skipped if NO_SYSTEM_ENVIRONMENT_PATH is an argument.\n"
	" PATH\n"
	" XXX_SYSTEM\n" // replace with "", LIB, or INCLUDE
	"5. Search cmake variables defined in the Platform files "
	"for the current system. This can be skipped if NO_CMAKE_SYSTEM_PATH "
	"is passed.\n"
	" <prefix>/XXX_SUBDIR for each <prefix> in CMAKE_SYSTEM_PREFIX_PATH\n"
	" CMAKE_SYSTEM_XXX_PATH\n"
	" CMAKE_SYSTEM_XXX_MAC_PATH\n"
	"6. Search the paths specified by the PATHS option "
	"or in the short-hand version of the command. "
	"These are typically hard-coded guesses.\n"
	;
	this->GenericDocumentation += this->GenericDocumentationMacPolicy;
	this->GenericDocumentation += this->GenericDocumentationRootPath;
	this->GenericDocumentation += this->GenericDocumentationPathsOrder;
	}

	bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
	{
	if(argsIn.size() < 2 )
	{
	this->SetError("called with incorrect number of arguments");
	return false;
	}

	// CMake versions below 2.3 did not search all these extra
	// locations. Preserve compatibility unless a modern argument is
	// passed.
	bool compatibility = this->Makefile->NeedBackwardsCompatibility(2,3);

	// copy argsIn into args so it can be modified,
	// in the process extract the DOC "documentation"
	size_t size = argsIn.size();
	std::vector<std::string> args;
	bool foundDoc = false;
	for(unsigned int j = 0; j < size; ++j)
	{
	if(foundDoc \|\| argsIn[j] != "DOC" )
	{
	if(argsIn[j] == "ENV")
	{
	if(j+1 < size)
	{
	j++;
	cmSystemTools::GetPath(args, argsIn[j].c_str());
	}
	}
	else
	{
	args.push_back(argsIn[j]);
	}
	}
	else
	{
	if(j+1 < size)
	{
	foundDoc = true;
	this->VariableDocumentation = argsIn[j+1];
	j++;
	if(j >= size)
	{
	break;
	}
	}
	}
	}
	this->VariableName = args[0];
	if(this->CheckForVariableInCache())
	{
	this->AlreadyInCache = true;
	return true;
	}
	this->AlreadyInCache = false;

	// Find the current root path mode.
	this->SelectDefaultRootPathMode();

	// Find the current bundle/framework search policy.
	this->SelectDefaultMacMode();

	bool newStyle = false;
	enum Doing { DoingNone, DoingNames, DoingPaths, DoingPathSuffixes,
	DoingHints };
	Doing doing = DoingNames; // assume it starts with a name
	for (unsigned int j = 1; j < args.size(); ++j)
	{
	if(args[j] == "NAMES")
	{
	doing = DoingNames;
	newStyle = true;
	}
	else if (args[j] == "PATHS")
	{
	doing = DoingPaths;
	newStyle = true;
	}
	else if (args[j] == "HINTS")
	{
	doing = DoingHints;
	newStyle = true;
	}
	else if (args[j] == "PATH_SUFFIXES")
	{
	doing = DoingPathSuffixes;
	compatibility = false;
	newStyle = true;
	}
	else if (args[j] == "NO_SYSTEM_PATH")
	{
	doing = DoingNone;
	this->NoDefaultPath = true;
	}
	else if (this->CheckCommonArgument(args[j]))
	{
	doing = DoingNone;
	compatibility = false;
	// Some common arguments were accidentally supported by CMake
	// 2.4 and 2.6.0 in the short-hand form of the command, so we
	// must support it even though it is not documented.
	}
	else if(doing == DoingNames)
	{
	this->Names.push_back(args[j]);
	}
	else if(doing == DoingPaths)
	{
	this->AddUserPath(args[j], this->UserPaths);
	}
	else if(doing == DoingHints)
	{
	this->AddUserPath(args[j], this->UserHints);
	}
	else if(doing == DoingPathSuffixes)
	{
	this->AddPathSuffix(args[j]);
	}
	}

	// Now that arguments have been parsed check the compatibility
	// setting. If we need to be compatible with CMake 2.2 and earlier
	// do not add the CMake system paths. It is safe to add the CMake
	// environment paths and system environment paths because that
	// existed in 2.2. It is safe to add the CMake user variable paths
	// because the user or project has explicitly set them.
	if(compatibility)
	{
	this->NoCMakeSystemPath = true;
	}

	if(this->VariableDocumentation.size() == 0)
	{
	this->VariableDocumentation = "Where can ";
	if(this->Names.size() == 0)
	{
	this->VariableDocumentation += "the (unknown) library be found";
	}
	else if(this->Names.size() == 1)
	{
	this->VariableDocumentation += "the "
	+ this->Names[0] + " library be found";
	}
	else
	{
	this->VariableDocumentation += "one of the " + this->Names[0];
	for (unsigned int j = 1; j < this->Names.size() - 1; ++j)
	{
	this->VariableDocumentation += ", " + this->Names[j];
	}
	this->VariableDocumentation += " or "
	+ this->Names[this->Names.size() - 1] + " libraries be found";
	}
	}

	// look for old style
	// FIND_*(VAR name path1 path2 ...)
	if(!newStyle)
	{
	// All the short-hand arguments have been recorded as names.
	std::vector<std::string> shortArgs = this->Names;
	this->Names.clear(); // clear out any values in Names
	this->Names.push_back(shortArgs[0]);
	for(unsigned int j = 1; j < shortArgs.size(); ++j)
	{
	this->AddUserPath(shortArgs[j], this->UserPaths);
	}
	}
	this->ExpandPaths();

	// Handle search root stuff.
	this->RerootPaths(this->SearchPaths);

	// Add a trailing slash to all prefixes to aid the search process.
	this->AddTrailingSlashes(this->SearchPaths);

	return true;
	}

	void cmFindBase::ExpandPaths()
	{
	this->AddCMakeVariablePath();
	this->AddCMakeEnvironmentPath();
	this->AddUserHintsPath();
	this->AddSystemEnvironmentPath();
	this->AddCMakeSystemVariablePath();
	this->AddUserGuessPath();

	// Add suffixes and clean up paths.
	this->AddPathSuffixes();
	}

	//----------------------------------------------------------------------------
	void cmFindBase::AddPrefixPaths(std::vector<std::string> const& in_paths,
	PathType pathType)
	{
	// default for programs
	std::string subdir = "bin";

	if (this->CMakePathName == "INCLUDE")
	{
	subdir = "include";
	}
	else if (this->CMakePathName == "LIBRARY")
	{
	subdir = "lib";
	}
	else if (this->CMakePathName == "FRAMEWORK")
	{
	subdir = ""; // ? what to do for frameworks ?
	}

	for(std::vector<std::string>::const_iterator it = in_paths.begin();
	it != in_paths.end(); ++it)
	{
	std::string dir = it->c_str();
	if(!subdir.empty() && !dir.empty() && dir[dir.size()-1] != '/')
	{
	dir += "/";
	}
	std::string add = dir + subdir;
	if(add != "/")
	{
	this->AddPathInternal(add, pathType);
	}
	if (subdir == "bin")
	{
	this->AddPathInternal(dir+"sbin", pathType);
	}
	if(!subdir.empty() && *it != "/")
	{
	this->AddPathInternal(*it, pathType);
	}
	}
	}

	//----------------------------------------------------------------------------
	void cmFindBase::AddCMakePrefixPath(const char* variable)
	{
	// Get a path from a CMake variable.
	if(const char* varPath = this->Makefile->GetDefinition(variable))
	{
	std::vector<std::string> tmp;
	cmSystemTools::ExpandListArgument(varPath, tmp);
	this->AddPrefixPaths(tmp, CMakePath);
	}
	}

	//----------------------------------------------------------------------------
	void cmFindBase::AddEnvPrefixPath(const char* variable)
	{
	// Get a path from the environment.
	std::vector<std::string> tmp;
	cmSystemTools::GetPath(tmp, variable);
	this->AddPrefixPaths(tmp, EnvPath);
	}

	//----------------------------------------------------------------------------
	void cmFindBase::AddCMakeEnvironmentPath()
	{
	if(!this->NoCMakeEnvironmentPath && !this->NoDefaultPath)
	{
	// Add CMAKE_*_PATH environment variables
	std::string var = "CMAKE_";
	var += this->CMakePathName;
	var += "_PATH";
	this->AddEnvPrefixPath("CMAKE_PREFIX_PATH");
	this->AddEnvPath(var.c_str());

	if(this->CMakePathName == "PROGRAM")
	{
	this->AddEnvPath("CMAKE_APPBUNDLE_PATH");
	}
	else
	{
	this->AddEnvPath("CMAKE_FRAMEWORK_PATH");
	}
	}
	}

	//----------------------------------------------------------------------------
	void cmFindBase::AddCMakeVariablePath()
	{
	if(!this->NoCMakePath && !this->NoDefaultPath)
	{
	// Add CMake varibles of the same name as the previous environment
	// varibles CMAKE_*_PATH to be used most of the time with -D
	// command line options
	std::string var = "CMAKE_";
	var += this->CMakePathName;
	var += "_PATH";
	this->AddCMakePrefixPath("CMAKE_PREFIX_PATH");
	this->AddCMakePath(var.c_str());

	if(this->CMakePathName == "PROGRAM")
	{
	this->AddCMakePath("CMAKE_APPBUNDLE_PATH");
	}
	else
	{
	this->AddCMakePath("CMAKE_FRAMEWORK_PATH");
	}
	}
	}

	//----------------------------------------------------------------------------
	void cmFindBase::AddSystemEnvironmentPath()
	{
	if(!this->NoSystemEnvironmentPath && !this->NoDefaultPath)
	{
	// Add LIB or INCLUDE
	if(!this->EnvironmentPath.empty())
	{
	this->AddEnvPath(this->EnvironmentPath.c_str());
	}
	// Add PATH
	this->AddEnvPath(0);
	}
	}

	//----------------------------------------------------------------------------
	void cmFindBase::AddCMakeSystemVariablePath()
	{
	if(!this->NoCMakeSystemPath && !this->NoDefaultPath)
	{
	std::string var = "CMAKE_SYSTEM_";
	var += this->CMakePathName;
	var += "_PATH";
	this->AddCMakePrefixPath("CMAKE_SYSTEM_PREFIX_PATH");
	this->AddCMakePath(var.c_str());

	if(this->CMakePathName == "PROGRAM")
	{
	this->AddCMakePath("CMAKE_SYSTEM_APPBUNDLE_PATH");
	}
	else
	{
	this->AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH");
	}
	}
	}

	//----------------------------------------------------------------------------
	void cmFindBase::AddUserHintsPath()
	{
	this->AddPathsInternal(this->UserHints, CMakePath);
	}

	//----------------------------------------------------------------------------
	void cmFindBase::AddUserGuessPath()
	{
	this->AddPathsInternal(this->UserPaths, CMakePath);
	}

	//----------------------------------------------------------------------------
	void cmFindBase::AddPathSuffixes()
	{
	std::vector<std::string>& paths = this->SearchPaths;
	std::vector<std::string> finalPath = paths;
	std::vector<std::string>::iterator i;
	// clear the path
	paths.clear();
	// convert all paths to unix slashes and add search path suffixes
	// if there are any
	for(i = finalPath.begin();
	i != finalPath.end(); ++i)
	{
	cmSystemTools::ConvertToUnixSlashes(*i);
	// copy each finalPath combined with SearchPathSuffixes
	// to the SearchPaths ivar
	for(std::vector<std::string>::iterator j =
	this->SearchPathSuffixes.begin();
	j != this->SearchPathSuffixes.end(); ++j)
	{
	// if *i is only / then do not add a //
	// this will get incorrectly considered a network
	// path on windows and cause huge delays.
	std::string p = *i;
	if(p.size() && p[p.size()-1] != '/')
	{
	p += std::string("/");
	}
	p += *j;
	// add to all paths because the search path may be modified
	// later with lib being replaced for lib64 which may exist
	paths.push_back(p);
	}
	}
	// now put the path without the path suffixes in the SearchPaths
	for(i = finalPath.begin();
	i != finalPath.end(); ++i)
	{
	// put all search paths in because it may later be replaced
	// by lib64 stuff fixes bug 4009
	paths.push_back(*i);
	}
	}

	void cmFindBase::PrintFindStuff()
	{
	std::cerr << "SearchFrameworkLast: " << this->SearchFrameworkLast << "\n";
	std::cerr << "SearchFrameworkOnly: " << this->SearchFrameworkOnly << "\n";
	std::cerr << "SearchFrameworkFirst: " << this->SearchFrameworkFirst << "\n";
	std::cerr << "SearchAppBundleLast: " << this->SearchAppBundleLast << "\n";
	std::cerr << "SearchAppBundleOnly: " << this->SearchAppBundleOnly << "\n";
	std::cerr << "SearchAppBundleFirst: " << this->SearchAppBundleFirst << "\n";
	std::cerr << "VariableName " << this->VariableName << "\n";
	std::cerr << "VariableDocumentation "
	<< this->VariableDocumentation << "\n";
	std::cerr << "NoDefaultPath " << this->NoDefaultPath << "\n";
	std::cerr << "NoCMakeEnvironmentPath "
	<< this->NoCMakeEnvironmentPath << "\n";
	std::cerr << "NoCMakePath " << this->NoCMakePath << "\n";
	std::cerr << "NoSystemEnvironmentPath "
	<< this->NoSystemEnvironmentPath << "\n";
	std::cerr << "NoCMakeSystemPath " << this->NoCMakeSystemPath << "\n";
	std::cerr << "EnvironmentPath " << this->EnvironmentPath << "\n";
	std::cerr << "CMakePathName " << this->CMakePathName << "\n";
	std::cerr << "Names ";
	for(unsigned int i =0; i < this->Names.size(); ++i)
	{
	std::cerr << this->Names[i] << " ";
	}
	std::cerr << "\n";
	std::cerr << "\n";
	std::cerr << "SearchPathSuffixes ";
	for(unsigned int i =0; i < this->SearchPathSuffixes.size(); ++i)
	{
	std::cerr << this->SearchPathSuffixes[i] << "\n";
	}
	std::cerr << "\n";
	std::cerr << "SearchPaths\n";
	for(unsigned int i =0; i < this->SearchPaths.size(); ++i)
	{
	std::cerr << "[" << this->SearchPaths[i] << "]\n";
	}
	}

	bool cmFindBase::CheckForVariableInCache()
	{
	if(const char* cacheValue =
	this->Makefile->GetDefinition(this->VariableName.c_str()))
	{
	cmCacheManager::CacheIterator it =
	this->Makefile->GetCacheManager()->
	GetCacheIterator(this->VariableName.c_str());
	bool found = !cmSystemTools::IsNOTFOUND(cacheValue);
	bool cached = !it.IsAtEnd();
	if(found)
	{
	// 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. Tell the subclass implementations to do
	// this.
	if(cached && it.GetType() == cmCacheManager::UNINITIALIZED)
	{
	this->AlreadyInCacheWithoutMetaInfo = true;
	}
	return true;
	}
	else if(cached)
	{
	const char* hs = it.GetProperty("HELPSTRING");
	this->VariableDocumentation = hs?hs:"(none)";
	}
	}
	return false;
	}