1 files changed, 333 insertions, 0 deletions
diff --git a/Source/cmFindBase.cxx b/Source/cmFindBase.cxx
new file mode 100644
index 0000000..082bbf0
--- /dev/null
+++ b/Source/cmFindBase.cxx
@@ -0,0 +1,333 @@
+/*============================================================================
+  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 "cmFindBase.h"
+
+#include "cmAlgorithms.h"
+#include "cmState.h"
+
+cmFindBase::cmFindBase()
+{
+  this->AlreadyInCache = false;
+  this->AlreadyInCacheWithoutMetaInfo = false;
+  this->NamesPerDir = false;
+  this->NamesPerDirAllowed = false;
+}
+
+bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
+{
+  if (argsIn.size() < 2) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+
+  // 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;
+        }
+      }
+    }
+  }
+  if (args.size() < 2) {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+  }
+  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;
+      newStyle = true;
+    } else if (args[j] == "NAMES_PER_DIR") {
+      doing = DoingNone;
+      if (this->NamesPerDirAllowed) {
+        this->NamesPerDir = true;
+      } else {
+        this->SetError("does not support NAMES_PER_DIR");
+        return false;
+      }
+    } else if (args[j] == "NO_SYSTEM_PATH") {
+      doing = DoingNone;
+      this->NoDefaultPath = true;
+    } else if (this->CheckCommonArgument(args[j])) {
+      doing = DoingNone;
+      // 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->UserGuessArgs.push_back(args[j]);
+    } else if (doing == DoingHints) {
+      this->UserHintsArgs.push_back(args[j]);
+    } else if (doing == DoingPathSuffixes) {
+      this->AddPathSuffix(args[j]);
+    }
+  }
+
+  if (this->VariableDocumentation.empty()) {
+    this->VariableDocumentation = "Where can ";
+    if (this->Names.empty()) {
+      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->VariableDocumentation +=
+        cmJoin(cmMakeRange(this->Names).retreat(1), ", ");
+      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]);
+    this->UserGuessArgs.insert(this->UserGuessArgs.end(),
+                               shortArgs.begin() + 1, shortArgs.end());
+  }
+  this->ExpandPaths();
+
+  this->ComputeFinalPaths();
+
+  return true;
+}
+
+void cmFindBase::ExpandPaths()
+{
+  if (!this->NoDefaultPath) {
+    if (!this->NoCMakePath) {
+      this->FillCMakeVariablePath();
+    }
+    if (!this->NoCMakeEnvironmentPath) {
+      this->FillCMakeEnvironmentPath();
+    }
+  }
+  this->FillUserHintsPath();
+  if (!this->NoDefaultPath) {
+    if (!this->NoSystemEnvironmentPath) {
+      this->FillSystemEnvironmentPath();
+    }
+    if (!this->NoCMakeSystemPath) {
+      this->FillCMakeSystemVariablePath();
+    }
+  }
+  this->FillUserGuessPath();
+}
+
+void cmFindBase::FillCMakeEnvironmentPath()
+{
+  cmSearchPath& paths = this->LabeledPaths[PathLabel::CMakeEnvironment];
+
+  // Add CMAKE_*_PATH environment variables
+  std::string var = "CMAKE_";
+  var += this->CMakePathName;
+  var += "_PATH";
+  paths.AddEnvPrefixPath("CMAKE_PREFIX_PATH");
+  paths.AddEnvPath(var);
+
+  if (this->CMakePathName == "PROGRAM") {
+    paths.AddEnvPath("CMAKE_APPBUNDLE_PATH");
+  } else {
+    paths.AddEnvPath("CMAKE_FRAMEWORK_PATH");
+  }
+  paths.AddSuffixes(this->SearchPathSuffixes);
+}
+
+void cmFindBase::FillCMakeVariablePath()
+{
+  cmSearchPath& paths = this->LabeledPaths[PathLabel::CMake];
+
+  // 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";
+  paths.AddCMakePrefixPath("CMAKE_PREFIX_PATH");
+  paths.AddCMakePath(var);
+
+  if (this->CMakePathName == "PROGRAM") {
+    paths.AddCMakePath("CMAKE_APPBUNDLE_PATH");
+  } else {
+    paths.AddCMakePath("CMAKE_FRAMEWORK_PATH");
+  }
+  paths.AddSuffixes(this->SearchPathSuffixes);
+}
+
+void cmFindBase::FillSystemEnvironmentPath()
+{
+  cmSearchPath& paths = this->LabeledPaths[PathLabel::SystemEnvironment];
+
+  // Add LIB or INCLUDE
+  if (!this->EnvironmentPath.empty()) {
+    paths.AddEnvPath(this->EnvironmentPath);
+#if defined(_WIN32) || defined(__CYGWIN__)
+    paths.AddEnvPrefixPath("PATH", true);
+    paths.AddEnvPath("PATH");
+#endif
+  } else {
+    // Add PATH
+    paths.AddEnvPath("PATH");
+  }
+  paths.AddSuffixes(this->SearchPathSuffixes);
+}
+
+void cmFindBase::FillCMakeSystemVariablePath()
+{
+  cmSearchPath& paths = this->LabeledPaths[PathLabel::CMakeSystem];
+
+  std::string var = "CMAKE_SYSTEM_";
+  var += this->CMakePathName;
+  var += "_PATH";
+  paths.AddCMakePrefixPath("CMAKE_SYSTEM_PREFIX_PATH");
+  paths.AddCMakePath(var);
+
+  if (this->CMakePathName == "PROGRAM") {
+    paths.AddCMakePath("CMAKE_SYSTEM_APPBUNDLE_PATH");
+  } else {
+    paths.AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH");
+  }
+  paths.AddSuffixes(this->SearchPathSuffixes);
+}
+
+void cmFindBase::FillUserHintsPath()
+{
+  cmSearchPath& paths = this->LabeledPaths[PathLabel::Hints];
+
+  for (std::vector<std::string>::const_iterator p =
+         this->UserHintsArgs.begin();
+       p != this->UserHintsArgs.end(); ++p) {
+    paths.AddUserPath(*p);
+  }
+  paths.AddSuffixes(this->SearchPathSuffixes);
+}
+
+void cmFindBase::FillUserGuessPath()
+{
+  cmSearchPath& paths = this->LabeledPaths[PathLabel::Guess];
+
+  for (std::vector<std::string>::const_iterator p =
+         this->UserGuessArgs.begin();
+       p != this->UserGuessArgs.end(); ++p) {
+    paths.AddUserPath(*p);
+  }
+  paths.AddSuffixes(this->SearchPathSuffixes);
+}
+
+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  " << cmJoin(this->Names, " ") << "\n";
+  std::cerr << "\n";
+  std::cerr << "SearchPathSuffixes  ";
+  std::cerr << cmJoin(this->SearchPathSuffixes, "\n") << "\n";
+  std::cerr << "SearchPaths\n";
+  std::cerr << cmWrap("[", this->SearchPaths, "]", "\n") << "\n";
+}
+
+bool cmFindBase::CheckForVariableInCache()
+{
+  if (const char* cacheValue =
+        this->Makefile->GetDefinition(this->VariableName)) {
+    cmState* state = this->Makefile->GetState();
+    const char* cacheEntry = state->GetCacheEntryValue(this->VariableName);
+    bool found = !cmSystemTools::IsNOTFOUND(cacheValue);
+    bool cached = cacheEntry ? true : false;
+    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 &&
+          state->GetCacheEntryType(this->VariableName) ==
+            cmState::UNINITIALIZED) {
+        this->AlreadyInCacheWithoutMetaInfo = true;
+      }
+      return true;
+    } else if (cached) {
+      const char* hs =
+        state->GetCacheEntryProperty(this->VariableName, "HELPSTRING");
+      this->VariableDocumentation = hs ? hs : "(none)";
+    }
+  }
+  return false;
+}