Merge topic 'minor-cleanups'

3917d86 Genex: Add a nullary form for CONFIG
5169130 Help: Document the target properties exported to IMPORTED targets.
ee21f1c CompatibleInterface: Test debugging of not-set property.
80e9fe9 Help: Note that language-specific 'built-ins' are set by the project command.
0b5bf8a Help: Mention CMAKE_DISABLE_FIND_PACKAGE_<PackageName> in package docs.
28c865b Tests: simplify Qt4 target usage
6cfe6b8 Help: Fix typo: 'target' -> 'target property'
b7deca4 Test: Remove obsolete commented code.
9c9f69f Genex: Make EQUAL support upper case binary literals
6eb3218 Genex: Fix case of methods in the dag checker.
646c6ec Genex: Use a preprocessor loop to implement transitive DAG check.
711fb38 Genex: List transitive properties and methods as a table, not two lists.
802a28f Add cmHasLiteralSuffix API.

6 files changed, 92 insertions, 71 deletions

diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx
index d051063..c59aafd 100644
--- a/Source/cmFindPackageCommand.cxx
+++ b/Source/cmFindPackageCommand.cxx
@@ -1151,8 +1151,8 @@ void cmFindPackageCommand::AddPrefixesSystemEnvironment()
       std::string const& d = *i;
 
       // If the path is a PREFIX/bin case then add its parent instead.
-      if((d.size() >= 4 && strcmp(d.c_str()+d.size()-4, "/bin") == 0) ||
-         (d.size() >= 5 && strcmp(d.c_str()+d.size()-5, "/sbin") == 0))
+      if((cmHasLiteralSuffix(d, "/bin")) ||
+         (cmHasLiteralSuffix(d, "/sbin")))
         {
         this->AddPathInternal(cmSystemTools::GetFilenamePath(d), EnvPath);
         }
diff --git a/Source/cmGeneratorExpressionDAGChecker.cxx b/Source/cmGeneratorExpressionDAGChecker.cxx
index c2c4e20..e7e1d34 100644
--- a/Source/cmGeneratorExpressionDAGChecker.cxx
+++ b/Source/cmGeneratorExpressionDAGChecker.cxx
@@ -31,7 +31,7 @@ cmGeneratorExpressionDAGChecker::cmGeneratorExpressionDAGChecker(
     top = p;
     p = p->Parent;
     }
-  this->CheckResult = this->checkGraph();
+  this->CheckResult = this->CheckGraph();
 
 #define TEST_TRANSITIVE_PROPERTY_METHOD(METHOD) \
   top->METHOD () ||
@@ -61,13 +61,13 @@ cmGeneratorExpressionDAGChecker::cmGeneratorExpressionDAGChecker(
 
 //----------------------------------------------------------------------------
 cmGeneratorExpressionDAGChecker::Result
-cmGeneratorExpressionDAGChecker::check() const
+cmGeneratorExpressionDAGChecker::Check() const
 {
   return this->CheckResult;
 }
 
 //----------------------------------------------------------------------------
-void cmGeneratorExpressionDAGChecker::reportError(
+void cmGeneratorExpressionDAGChecker::ReportError(
                   cmGeneratorExpressionContext *context,
                   const std::string &expr)
 {
@@ -125,7 +125,7 @@ void cmGeneratorExpressionDAGChecker::reportError(
 
 //----------------------------------------------------------------------------
 cmGeneratorExpressionDAGChecker::Result
-cmGeneratorExpressionDAGChecker::checkGraph() const
+cmGeneratorExpressionDAGChecker::CheckGraph() const
 {
   const cmGeneratorExpressionDAGChecker *parent = this->Parent;
   while (parent)
@@ -179,44 +179,37 @@ bool cmGeneratorExpressionDAGChecker::EvaluatingLinkLibraries(const char *tgt)
        || strcmp(prop, "INTERFACE_LINK_LIBRARIES") == 0;
 }
 
-//----------------------------------------------------------------------------
-bool cmGeneratorExpressionDAGChecker::EvaluatingIncludeDirectories() const
-{
-  const char *prop = this->Property.c_str();
-  return (strcmp(prop, "INCLUDE_DIRECTORIES") == 0
-       || strcmp(prop, "INTERFACE_INCLUDE_DIRECTORIES") == 0 );
-}
+enum TransitiveProperty {
+#define DEFINE_ENUM_ENTRY(NAME) NAME,
+  CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(DEFINE_ENUM_ENTRY)
+#undef DEFINE_ENUM_ENTRY
+  TransitivePropertyTerminal
+};
 
-//----------------------------------------------------------------------------
-bool
-cmGeneratorExpressionDAGChecker::EvaluatingSystemIncludeDirectories() const
+template<TransitiveProperty>
+bool additionalTest(const char* const)
 {
-  const char *prop = this->Property.c_str();
-  return (strcmp(prop, "SYSTEM_INCLUDE_DIRECTORIES") == 0
-       || strcmp(prop, "INTERFACE_SYSTEM_INCLUDE_DIRECTORIES") == 0);
+  return false;
 }
 
-//----------------------------------------------------------------------------
-bool cmGeneratorExpressionDAGChecker::EvaluatingCompileDefinitions() const
+template<>
+bool additionalTest<COMPILE_DEFINITIONS>(const char* const prop)
 {
-  const char *prop = this->Property.c_str();
-  return (strcmp(prop, "COMPILE_DEFINITIONS") == 0
-       || strcmp(prop, "INTERFACE_COMPILE_DEFINITIONS") == 0
-       || cmHasLiteralPrefix(prop, "COMPILE_DEFINITIONS_"));
+  return cmHasLiteralPrefix(prop, "COMPILE_DEFINITIONS_");
 }
 
-//----------------------------------------------------------------------------
-bool cmGeneratorExpressionDAGChecker::EvaluatingCompileOptions() const
-{
-  const char *prop = this->Property.c_str();
-  return (strcmp(prop, "COMPILE_OPTIONS") == 0
-       || strcmp(prop, "INTERFACE_COMPILE_OPTIONS") == 0 );
+#define DEFINE_TRANSITIVE_PROPERTY_METHOD(METHOD, PROPERTY) \
+bool cmGeneratorExpressionDAGChecker::METHOD() const \
+{ \
+  const char* const prop = this->Property.c_str(); \
+  if (strcmp(prop, #PROPERTY) == 0 \
+      || strcmp(prop, "INTERFACE_" #PROPERTY) == 0) \
+    { \
+    return true; \
+    } \
+  return additionalTest<PROPERTY>(prop); \
 }
 
-//----------------------------------------------------------------------------
-bool cmGeneratorExpressionDAGChecker::EvaluatingAutoUicOptions() const
-{
-  const char *prop = this->Property.c_str();
-  return (strcmp(prop, "AUTOUIC_OPTIONS") == 0
-       || strcmp(prop, "INTERFACE_AUTOUIC_OPTIONS") == 0 );
-}
+CM_FOR_EACH_TRANSITIVE_PROPERTY(DEFINE_TRANSITIVE_PROPERTY_METHOD)
+
+#undef DEFINE_TRANSITIVE_PROPERTY_METHOD
diff --git a/Source/cmGeneratorExpressionDAGChecker.h b/Source/cmGeneratorExpressionDAGChecker.h
index 98ffd36..b6effa1 100644
--- a/Source/cmGeneratorExpressionDAGChecker.h
+++ b/Source/cmGeneratorExpressionDAGChecker.h
@@ -16,19 +16,25 @@
 
 #include "cmGeneratorExpressionEvaluator.h"
 
+#define CM_SELECT_BOTH(F, A1, A2) F(A1, A2)
+#define CM_SELECT_FIRST(F, A1, A2) F(A1)
+#define CM_SELECT_SECOND(F, A1, A2) F(A2)
+
+#define CM_FOR_EACH_TRANSITIVE_PROPERTY_IMPL(F, SELECT) \
+  SELECT(F, EvaluatingIncludeDirectories,       INCLUDE_DIRECTORIES) \
+  SELECT(F, EvaluatingSystemIncludeDirectories, SYSTEM_INCLUDE_DIRECTORIES) \
+  SELECT(F, EvaluatingCompileDefinitions,       COMPILE_DEFINITIONS) \
+  SELECT(F, EvaluatingCompileOptions,           COMPILE_OPTIONS) \
+  SELECT(F, EvaluatingAutoUicOptions,           AUTOUIC_OPTIONS)
+
+#define CM_FOR_EACH_TRANSITIVE_PROPERTY(F) \
+  CM_FOR_EACH_TRANSITIVE_PROPERTY_IMPL(F, CM_SELECT_BOTH)
+
 #define CM_FOR_EACH_TRANSITIVE_PROPERTY_METHOD(F) \
-  F(EvaluatingIncludeDirectories) \
-  F(EvaluatingSystemIncludeDirectories) \
-  F(EvaluatingCompileDefinitions) \
-  F(EvaluatingCompileOptions) \
-  F(EvaluatingAutoUicOptions)
+  CM_FOR_EACH_TRANSITIVE_PROPERTY_IMPL(F, CM_SELECT_FIRST)
 
 #define CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(F) \
-  F(INCLUDE_DIRECTORIES) \
-  F(SYSTEM_INCLUDE_DIRECTORIES) \
-  F(COMPILE_DEFINITIONS) \
-  F(COMPILE_OPTIONS) \
-  F(AUTOUIC_OPTIONS)
+  CM_FOR_EACH_TRANSITIVE_PROPERTY_IMPL(F, CM_SELECT_SECOND)
 
 //----------------------------------------------------------------------------
 struct cmGeneratorExpressionDAGChecker
@@ -46,9 +52,9 @@ struct cmGeneratorExpressionDAGChecker
     ALREADY_SEEN
   };
 
-  Result check() const;
+  Result Check() const;
 
-  void reportError(cmGeneratorExpressionContext *context,
+  void ReportError(cmGeneratorExpressionContext *context,
                    const std::string &expr);
 
   bool EvaluatingLinkLibraries(const char *tgt = 0);
@@ -65,7 +71,7 @@ struct cmGeneratorExpressionDAGChecker
     { this->TransitivePropertiesOnly = true; }
 
 private:
-  Result checkGraph() const;
+  Result CheckGraph() const;
 
 private:
   const cmGeneratorExpressionDAGChecker * const Parent;
diff --git a/Source/cmGeneratorExpressionEvaluator.cxx b/Source/cmGeneratorExpressionEvaluator.cxx
index f0e40ea..5edea86 100644
--- a/Source/cmGeneratorExpressionEvaluator.cxx
+++ b/Source/cmGeneratorExpressionEvaluator.cxx
@@ -215,18 +215,18 @@ static const struct EqualNode : public cmGeneratorExpressionNode
     bool flipSign = false;
 
     const char *lhs = parameters[0].c_str();
-    if (cmHasLiteralPrefix(lhs, "0b"))
+    if (cmHasLiteralPrefix(lhs, "0b") || cmHasLiteralPrefix(lhs, "0B"))
       {
       base = 2;
       lhs += 2;
       }
-    if (cmHasLiteralPrefix(lhs, "-0b"))
+    if (cmHasLiteralPrefix(lhs, "-0b") || cmHasLiteralPrefix(lhs, "-0B"))
       {
       base = 2;
       lhs += 3;
       flipSign = true;
       }
-    if (cmHasLiteralPrefix(lhs, "+0b"))
+    if (cmHasLiteralPrefix(lhs, "+0b") || cmHasLiteralPrefix(lhs, "+0B"))
       {
       base = 2;
       lhs += 3;
@@ -249,18 +249,18 @@ static const struct EqualNode : public cmGeneratorExpressionNode
     flipSign = false;
 
     const char *rhs = parameters[1].c_str();
-    if (cmHasLiteralPrefix(rhs, "0b"))
+    if (cmHasLiteralPrefix(rhs, "0b") || cmHasLiteralPrefix(rhs, "0B"))
       {
       base = 2;
       rhs += 2;
       }
-    if (cmHasLiteralPrefix(rhs, "-0b"))
+    if (cmHasLiteralPrefix(rhs, "-0b") || cmHasLiteralPrefix(rhs, "-0B"))
       {
       base = 2;
       rhs += 3;
       flipSign = true;
       }
-    if (cmHasLiteralPrefix(rhs, "+0b"))
+    if (cmHasLiteralPrefix(rhs, "+0b") || cmHasLiteralPrefix(rhs, "+0B"))
       {
       base = 2;
       rhs += 3;
@@ -676,13 +676,17 @@ static const struct ConfigurationTestNode : public cmGeneratorExpressionNode
 {
   ConfigurationTestNode() {}
 
-  virtual int NumExpectedParameters() const { return 1; }
+  virtual int NumExpectedParameters() const { return OneOrZeroParameters; }
 
   std::string Evaluate(const std::vector<std::string> &parameters,
                        cmGeneratorExpressionContext *context,
                        const GeneratorExpressionContent *content,
                        cmGeneratorExpressionDAGChecker *) const
   {
+    if (parameters.empty())
+      {
+      return configurationNode.Evaluate(parameters, context, content, 0);
+      }
     cmsys::RegularExpression configValidator;
     configValidator.compile("^[A-Za-z0-9_]*$");
     if (!configValidator.find(parameters.begin()->c_str()))
@@ -957,10 +961,10 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode
                                                content,
                                                dagCheckerParent);
 
-    switch (dagChecker.check())
+    switch (dagChecker.Check())
       {
     case cmGeneratorExpressionDAGChecker::SELF_REFERENCE:
-      dagChecker.reportError(context, content->GetOriginalExpression());
+      dagChecker.ReportError(context, content->GetOriginalExpression());
       return std::string();
     case cmGeneratorExpressionDAGChecker::CYCLIC_REFERENCE:
       // No error. We just skip cyclic references.
@@ -1801,7 +1805,7 @@ std::string GeneratorExpressionContent::EvaluateParameters(
                       + "> expression requires at least one parameter.");
     }
   if (numExpected == cmGeneratorExpressionNode::OneOrZeroParameters
-      && parameters.size() > 2)
+      && parameters.size() > 1)
     {
     reportError(context, this->GetOriginalExpression(), "$<" + identifier
                       + "> expression requires one or zero parameters.");
diff --git a/Source/cmStandardIncludes.h b/Source/cmStandardIncludes.h
index eb6e52f..ebfa8f9 100644
--- a/Source/cmStandardIncludes.h
+++ b/Source/cmStandardIncludes.h
@@ -391,6 +391,22 @@ inline bool cmHasLiteralPrefixImpl(const char* str1,
   return strncmp(str1, str2, N) == 0;
 }
 
+inline bool cmHasLiteralSuffixImpl(const std::string &str1,
+                                   const char *str2,
+                                   size_t N)
+{
+  size_t len = str1.size();
+  return len >= N && strcmp(str1.c_str() + len - N, str2) == 0;
+}
+
+inline bool cmHasLiteralSuffixImpl(const char* str1,
+                                   const char* str2,
+                                   size_t N)
+{
+  size_t len = strlen(str1);
+  return len >= N && strcmp(str1 + len - N, str2) == 0;
+}
+
 #if defined(_MSC_VER) && _MSC_VER < 1300 \
   || defined(__GNUC__) && __GNUC__ < 3 \
   || defined(__BORLANDC__)
@@ -402,6 +418,9 @@ inline bool cmHasLiteralPrefixImpl(const char* str1,
 #define cmHasLiteralPrefix(STR1, STR2) \
   cmHasLiteralPrefixImpl(STR1, "" STR2 "", sizeof(STR2) - 1)
 
+#define cmHasLiteralSuffix(STR1, STR2) \
+  cmHasLiteralSuffixImpl(STR1, "" STR2 "", sizeof(STR2) - 1)
+
 #else
 
 template<typename T, size_t N>
@@ -417,6 +436,12 @@ bool cmHasLiteralPrefix(T str1, const char (&str2)[N])
   return cmHasLiteralPrefixImpl(str1, str2, N - 1);
 }
 
+template<typename T, size_t N>
+bool cmHasLiteralSuffix(T str1, const char (&str2)[N])
+{
+  return cmHasLiteralSuffixImpl(str1, str2, N - 1);
+}
+
 #endif
 
 struct cmStrCmp {
diff --git a/Source/cmSystemTools.cxx b/Source/cmSystemTools.cxx
index e8e2007..41c7509 100644
--- a/Source/cmSystemTools.cxx
+++ b/Source/cmSystemTools.cxx
@@ -360,18 +360,11 @@ bool cmSystemTools::IsOn(const char* val)
 
 bool cmSystemTools::IsNOTFOUND(const char* val)
 {
-  size_t len = strlen(val);
-  const char* notfound = "-NOTFOUND";
-  const size_t lenNotFound = 9;
-  if(len < lenNotFound-1)
+  if(strcmp(val, "NOTFOUND") == 0)
     {
-    return false;
-    }
-  if(len == lenNotFound-1)
-    {
-    return ( strcmp(val, "NOTFOUND") == 0);
+    return true;
     }
-  return ((strncmp((val + (len - lenNotFound)), notfound, lenNotFound) == 0));
+  return cmHasLiteralSuffix(val, "-NOTFOUND");
 }