Commit 4887640b by Brad King 💬 Committed by Kitware Robot

### Merge topic 'add-extra-boolean-comparisons'

`02d177c9 Add additional <= and >= comparison operators`
parents 5aabfec9 02d177c9
 ... ... @@ -30,10 +30,12 @@ else and endif clause is optional. Long expressions can be used and there is a traditional order of precedence. Parenthetical expressions are evaluated first followed by unary tests such as ``EXISTS``, ``COMMAND``, and ``DEFINED``. Then any binary tests such as ``EQUAL``, ``LESS``, ``GREATER``, ``STRLESS``, ``STRGREATER``, ``STREQUAL``, and ``MATCHES`` will be evaluated. Then boolean ``NOT`` operators and finally boolean ``AND`` and then ``OR`` operators will be evaluated. ``EQUAL``, ``LESS``, ``LESS_EQUAL, ``GREATER``, ``GREATER_EQUAL``, ``STREQUAL``, ``STRLESS``, ``STRLESS_EQUAL``, ``STRGREATER``, ``STRGREATER_EQUAL``, ``VERSION_EQUAL``, ``VERSION_LESS``, ``VERSION_LESS_EQUAL``, ``VERSION_GREATER``, ``VERSION_GREATER_EQUAL``, and ``MATCHES`` will be evaluated. Then boolean ``NOT`` operators and finally boolean ``AND`` and then ``OR`` operators will be evaluated. Possible expressions are: ... ... @@ -115,6 +117,14 @@ Possible expressions are: True if the given string or variable's value is a valid number and equal to that on the right. ``if( LESS_EQUAL )`` True if the given string or variable's value is a valid number and less than or equal to that on the right. ``if( GREATER_EQUAL )`` True if the given string or variable's value is a valid number and greater than or equal to that on the right. ``if( STRLESS )`` True if the given string or variable's value is lexicographically less than the string or variable on the right. ... ... @@ -127,15 +137,31 @@ Possible expressions are: True if the given string or variable's value is lexicographically equal to the string or variable on the right. ``if( STRLESS_EQUAL )`` True if the given string or variable's value is lexicographically less than or equal to the string or variable on the right. ``if( STRGREATER_EQUAL )`` True if the given string or variable's value is lexicographically greater than or equal to the string or variable on the right. ``if( VERSION_LESS )`` Component-wise integer version number comparison (version format is ``major[.minor[.patch[.tweak]]]``). ``if( VERSION_GREATER )`` Component-wise integer version number comparison (version format is ``major[.minor[.patch[.tweak]]]``). ``if( VERSION_EQUAL )`` Component-wise integer version number comparison (version format is ``major[.minor[.patch[.tweak]]]``). ``if( VERSION_GREATER )`` ``if( VERSION_LESS_EQUAL )`` Component-wise integer version number comparison (version format is ``major[.minor[.patch[.tweak]]]``). ``if( VERSION_GREATER_EQUAL )`` Component-wise integer version number comparison (version format is ``major[.minor[.patch[.tweak]]]``). ... ... @@ -186,20 +212,21 @@ above-documented signature accepts ````: * If the left hand argument to ``MATCHES`` is missing it returns false without error * Both left and right hand arguments to ``LESS``, ``GREATER``, and ``EQUAL`` are independently tested to see if they are defined variables, if so their defined values are used otherwise the original value is used. * Both left and right hand arguments to ``LESS``, ``GREATER``, ``EQUAL``, ``LESS_EQUAL``, and ``GREATER_EQUAL``, are independently tested to see if they are defined variables, if so their defined values are used otherwise the original value is used. * Both left and right hand arguments to ``STRLESS``, ``STREQUAL``, and ``STRGREATER`` are independently tested to see if they are defined variables, if so their defined values are used otherwise the original value is used. * Both left and right hand arguments to ``STRLESS``, ``STRGREATER``, ``STREQUAL``, ``STRLESS_EQUAL``, and ``STRGREATER_EQUAL`` are independently tested to see if they are defined variables, if so their defined values are used otherwise the original value is used. * Both left and right hand arguments to ``VERSION_LESS``, ``VERSION_EQUAL``, and ``VERSION_GREATER`` are independently tested to see if they are defined variables, if so their defined values are used otherwise the original value is used. ``VERSION_GREATER``, ``VERSION_EQUAL``, ``VERSION_LESS_EQUAL``, and ``VERSION_GREATER_EQUAL`` are independently tested to see if they are defined variables, if so their defined values are used otherwise the original value is used. * The right hand argument to ``NOT`` is tested to see if it is a boolean constant, if so the value is used, otherwise it is assumed to be a ... ...
 ... ... @@ -197,10 +197,12 @@ Comparison :: string(COMPARE EQUAL ) string(COMPARE NOTEQUAL ) string(COMPARE LESS ) string(COMPARE GREATER ) string(COMPARE EQUAL ) string(COMPARE NOTEQUAL ) string(COMPARE LESS_EQUAL ) string(COMPARE GREATER_EQUAL ) Compare the strings and store true or false in the output variable. ... ...
 ... ... @@ -66,12 +66,16 @@ Available logical expressions are: ``1`` if the CMake-id of the C compiler matches ``comp``, otherwise ``0``. ``\$`` ``1`` if the CMake-id of the CXX compiler matches ``comp``, otherwise ``0``. ``\$`` ``1`` if ``v1`` is a version greater than ``v2``, else ``0``. ``\$`` ``1`` if ``v1`` is a version less than ``v2``, else ``0``. ``\$`` ``1`` if ``v1`` is a version greater than ``v2``, else ``0``. ``\$`` ``1`` if ``v1`` is the same version as ``v2``, else ``0``. ``\$`` ``1`` if ``v1`` is a version less than or equal to ``v2``, else ``0``. ``\$`` ``1`` if ``v1`` is a version greater than or equal to ``v2``, else ``0``. ``\$`` ``1`` if the version of the C compiler matches ``ver``, otherwise ``0``. ``\$`` ... ...
 add-extra-boolean-comparisons ----------------------------- * The :command:`if` command gained new boolean comparison operations ``LESS_EQUAL``, ``GREATER_EQUAL``, ``STRLESS_EQUAL``, ``STRGREATER_EQUAL``, ``VERSION_LESS_EQUAL``, and ``VERSION_GREATER_EQUAL``.
 ... ... @@ -26,11 +26,11 @@ Individual component values are also available in variables: * :variable:`CMAKE_PATCH_VERSION` * :variable:`CMAKE_TWEAK_VERSION` Use the :command:`if` command ``VERSION_LESS``, ``VERSION_EQUAL``, or ``VERSION_GREATER`` operators to compare version string values against ``CMAKE_VERSION`` using a component-wise test. Version component values may be 10 or larger so do not attempt to compare version strings as floating-point numbers. Use the :command:`if` command ``VERSION_LESS``, ``VERSION_GREATER``, ``VERSION_EQUAL``, ``VERSION_LESS_EQUAL``, or ``VERSION_GREATER_EQUAL`` operators to compare version string values against ``CMAKE_VERSION`` using a component-wise test. Version component values may be 10 or larger so do not attempt to compare version strings as floating-point numbers. .. note:: ... ...
 ... ... @@ -366,11 +366,8 @@ bool cmCTest::ShouldCompressTestOutput() if (!this->ComputedCompressTestOutput) { std::string cdashVersion = this->GetCDashVersion(); // version >= 1.6? bool cdashSupportsGzip = cmSystemTools::VersionCompare(cmSystemTools::OP_GREATER, cdashVersion.c_str(), "1.6") || cmSystemTools::VersionCompare(cmSystemTools::OP_EQUAL, cdashVersion.c_str(), "1.6"); bool cdashSupportsGzip = cmSystemTools::VersionCompare( cmSystemTools::OP_GREATER_EQUAL, cdashVersion.c_str(), "1.6"); this->CompressTestOutput &= cdashSupportsGzip; this->ComputedCompressTestOutput = true; } ... ...
 ... ... @@ -21,12 +21,14 @@ static std::string const keyDEFINED = "DEFINED"; static std::string const keyEQUAL = "EQUAL"; static std::string const keyEXISTS = "EXISTS"; static std::string const keyGREATER = "GREATER"; static std::string const keyGREATER_EQUAL = "GREATER_EQUAL"; static std::string const keyIN_LIST = "IN_LIST"; static std::string const keyIS_ABSOLUTE = "IS_ABSOLUTE"; static std::string const keyIS_DIRECTORY = "IS_DIRECTORY"; static std::string const keyIS_NEWER_THAN = "IS_NEWER_THAN"; static std::string const keyIS_SYMLINK = "IS_SYMLINK"; static std::string const keyLESS = "LESS"; static std::string const keyLESS_EQUAL = "LESS_EQUAL"; static std::string const keyMATCHES = "MATCHES"; static std::string const keyNOT = "NOT"; static std::string const keyOR = "OR"; ... ... @@ -35,12 +37,16 @@ static std::string const keyParenR = ")"; static std::string const keyPOLICY = "POLICY"; static std::string const keySTREQUAL = "STREQUAL"; static std::string const keySTRGREATER = "STRGREATER"; static std::string const keySTRGREATER_EQUAL = "STRGREATER_EQUAL"; static std::string const keySTRLESS = "STRLESS"; static std::string const keySTRLESS_EQUAL = "STRLESS_EQUAL"; static std::string const keyTARGET = "TARGET"; static std::string const keyTEST = "TEST"; static std::string const keyVERSION_EQUAL = "VERSION_EQUAL"; static std::string const keyVERSION_GREATER = "VERSION_GREATER"; static std::string const keyVERSION_GREATER_EQUAL = "VERSION_GREATER_EQUAL"; static std::string const keyVERSION_LESS = "VERSION_LESS"; static std::string const keyVERSION_LESS_EQUAL = "VERSION_LESS_EQUAL"; cmConditionEvaluator::cmConditionEvaluator(cmMakefile& makefile, const cmListFileContext& context, ... ... @@ -559,7 +565,9 @@ bool cmConditionEvaluator::HandleLevel2(cmArgumentList& newArgs, if (argP1 != newArgs.end() && argP2 != newArgs.end() && (this->IsKeyword(keyLESS, *argP1) || this->IsKeyword(keyLESS_EQUAL, *argP1) || this->IsKeyword(keyGREATER, *argP1) || this->IsKeyword(keyGREATER_EQUAL, *argP1) || this->IsKeyword(keyEQUAL, *argP1))) { def = this->GetVariableOrString(*arg); def2 = this->GetVariableOrString(*argP2); ... ... @@ -570,8 +578,12 @@ bool cmConditionEvaluator::HandleLevel2(cmArgumentList& newArgs, result = false; } else if (*(argP1) == keyLESS) { result = (lhs < rhs); } else if (*(argP1) == keyLESS_EQUAL) { result = (lhs <= rhs); } else if (*(argP1) == keyGREATER) { result = (lhs > rhs); } else if (*(argP1) == keyGREATER_EQUAL) { result = (lhs >= rhs); } else { result = (lhs == rhs); } ... ... @@ -580,16 +592,22 @@ bool cmConditionEvaluator::HandleLevel2(cmArgumentList& newArgs, if (argP1 != newArgs.end() && argP2 != newArgs.end() && (this->IsKeyword(keySTRLESS, *argP1) || this->IsKeyword(keySTREQUAL, *argP1) || this->IsKeyword(keySTRGREATER, *argP1))) { this->IsKeyword(keySTRLESS_EQUAL, *argP1) || this->IsKeyword(keySTRGREATER, *argP1) || this->IsKeyword(keySTRGREATER_EQUAL, *argP1) || this->IsKeyword(keySTREQUAL, *argP1))) { def = this->GetVariableOrString(*arg); def2 = this->GetVariableOrString(*argP2); int val = strcmp(def, def2); bool result; if (*(argP1) == keySTRLESS) { result = (val < 0); } else if (*(argP1) == keySTRLESS_EQUAL) { result = (val <= 0); } else if (*(argP1) == keySTRGREATER) { result = (val > 0); } else if (*(argP1) == keySTRGREATER_EQUAL) { result = (val >= 0); } else // strequal { result = (val == 0); ... ... @@ -599,15 +617,23 @@ bool cmConditionEvaluator::HandleLevel2(cmArgumentList& newArgs, if (argP1 != newArgs.end() && argP2 != newArgs.end() && (this->IsKeyword(keyVERSION_LESS, *argP1) || this->IsKeyword(keyVERSION_LESS_EQUAL, *argP1) || this->IsKeyword(keyVERSION_GREATER, *argP1) || this->IsKeyword(keyVERSION_GREATER_EQUAL, *argP1) || this->IsKeyword(keyVERSION_EQUAL, *argP1))) { def = this->GetVariableOrString(*arg); def2 = this->GetVariableOrString(*argP2); cmSystemTools::CompareOp op = cmSystemTools::OP_EQUAL; cmSystemTools::CompareOp op; if (*argP1 == keyVERSION_LESS) { op = cmSystemTools::OP_LESS; } else if (*argP1 == keyVERSION_LESS_EQUAL) { op = cmSystemTools::OP_LESS_EQUAL; } else if (*argP1 == keyVERSION_GREATER) { op = cmSystemTools::OP_GREATER; } else if (*argP1 == keyVERSION_GREATER_EQUAL) { op = cmSystemTools::OP_GREATER_EQUAL; } else { // version_equal op = cmSystemTools::OP_EQUAL; } bool result = cmSystemTools::VersionCompare(op, def, def2); this->HandleBinaryOp(result, reducible, arg, newArgs, argP1, argP2); ... ...
 ... ... @@ -545,6 +545,25 @@ static const struct VersionGreaterNode : public cmGeneratorExpressionNode } } versionGreaterNode; static const struct VersionGreaterEqNode : public cmGeneratorExpressionNode { VersionGreaterEqNode() {} int NumExpectedParameters() const CM_OVERRIDE { return 2; } std::string Evaluate(const std::vector& parameters, cmGeneratorExpressionContext*, const GeneratorExpressionContent*, cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { return cmSystemTools::VersionCompare(cmSystemTools::OP_GREATER_EQUAL, parameters.front().c_str(), parameters[1].c_str()) ? "1" : "0"; } } versionGreaterEqNode; static const struct VersionLessNode : public cmGeneratorExpressionNode { VersionLessNode() {} ... ... @@ -564,6 +583,25 @@ static const struct VersionLessNode : public cmGeneratorExpressionNode } } versionLessNode; static const struct VersionLessEqNode : public cmGeneratorExpressionNode { VersionLessEqNode() {} int NumExpectedParameters() const CM_OVERRIDE { return 2; } std::string Evaluate(const std::vector& parameters, cmGeneratorExpressionContext*, const GeneratorExpressionContent*, cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { return cmSystemTools::VersionCompare(cmSystemTools::OP_LESS_EQUAL, parameters.front().c_str(), parameters[1].c_str()) ? "1" : "0"; } } versionLessEqNode; static const struct VersionEqualNode : public cmGeneratorExpressionNode { VersionEqualNode() {} ... ... @@ -1641,7 +1679,9 @@ const cmGeneratorExpressionNode* cmGeneratorExpressionNode::GetNode( nodeMap["C_COMPILER_ID"] = &cCompilerIdNode; nodeMap["CXX_COMPILER_ID"] = &cxxCompilerIdNode; nodeMap["VERSION_GREATER"] = &versionGreaterNode; nodeMap["VERSION_GREATER_EQUAL"] = &versionGreaterEqNode; nodeMap["VERSION_LESS"] = &versionLessNode; nodeMap["VERSION_LESS_EQUAL"] = &versionLessEqNode; nodeMap["VERSION_EQUAL"] = &versionEqualNode; nodeMap["C_COMPILER_VERSION"] = &cCompilerVersionNode; nodeMap["CXX_COMPILER_VERSION"] = &cxxCompilerVersionNode; ... ...
 ... ... @@ -485,7 +485,8 @@ bool cmStringCommand::HandleCompareCommand( } std::string mode = args[1]; if ((mode == "EQUAL") || (mode == "NOTEQUAL") || (mode == "LESS") || (mode == "GREATER")) { (mode == "LESS_EQUAL") || (mode == "GREATER") || (mode == "GREATER_EQUAL")) { if (args.size() < 5) { std::string e = "sub-command COMPARE, mode "; e += mode; ... ... @@ -500,8 +501,12 @@ bool cmStringCommand::HandleCompareCommand( bool result; if (mode == "LESS") { result = (left < right); } else if (mode == "LESS_EQUAL") { result = (left <= right); } else if (mode == "GREATER") { result = (left > right); } else if (mode == "GREATER_EQUAL") { result = (left >= right); } else if (mode == "EQUAL") { result = (left == right); } else // if(mode == "NOTEQUAL") ... ...
 ... ... @@ -2380,10 +2380,10 @@ bool cmSystemTools::VersionCompare(cmSystemTools::CompareOp op, if (lhs < rhs) { // lhs < rhs, so true if operation is LESS return op == cmSystemTools::OP_LESS; return (op & cmSystemTools::OP_LESS) != 0; } else if (lhs > rhs) { // lhs > rhs, so true if operation is GREATER return op == cmSystemTools::OP_GREATER; return (op & cmSystemTools::OP_GREATER) != 0; } if (*endr == '.') { ... ... @@ -2395,7 +2395,7 @@ bool cmSystemTools::VersionCompare(cmSystemTools::CompareOp op, } } // lhs == rhs, so true if operation is EQUAL return op == cmSystemTools::OP_EQUAL; return (op & cmSystemTools::OP_EQUAL) != 0; } bool cmSystemTools::VersionCompareEqual(std::string const& lhs, ... ... @@ -2412,6 +2412,13 @@ bool cmSystemTools::VersionCompareGreater(std::string const& lhs, rhs.c_str()); } bool cmSystemTools::VersionCompareGreaterEq(std::string const& lhs, std::string const& rhs) { return cmSystemTools::VersionCompare(cmSystemTools::OP_GREATER_EQUAL, lhs.c_str(), rhs.c_str()); } bool cmSystemTools::RemoveRPath(std::string const& file, std::string* emsg, bool* removed) { ... ...
 ... ... @@ -284,9 +284,11 @@ public: enum CompareOp { OP_LESS, OP_GREATER, OP_EQUAL OP_EQUAL = 1, OP_LESS = 2, OP_GREATER = 4, OP_LESS_EQUAL = OP_LESS | OP_EQUAL, OP_GREATER_EQUAL = OP_GREATER | OP_EQUAL }; /** ... ... @@ -297,6 +299,8 @@ public: std::string const& rhs); static bool VersionCompareGreater(std::string const& lhs, std::string const& rhs); static bool VersionCompareGreaterEq(std::string const& lhs, std::string const& rhs); /** * Determine the file type based on the extension ... ...
 ... ... @@ -83,10 +83,24 @@ foreach(v IN LISTS LESSV) message(FATAL_ERROR "\${CMAKE_MATCH_2} is less than \${CMAKE_MATCH_1}?") endif() # check greater or equal (same as less negative) if(CMAKE_MATCH_2 VERSION_GREATER_EQUAL CMAKE_MATCH_1) message(STATUS "\${CMAKE_MATCH_2} is not less than \${CMAKE_MATCH_1}") else() message(FATAL_ERROR "\${CMAKE_MATCH_2} is less than \${CMAKE_MATCH_1}?") endif() # check greater negative case if(NOT CMAKE_MATCH_1 VERSION_GREATER CMAKE_MATCH_2) message(STATUS "\${CMAKE_MATCH_1} is not greater than \${CMAKE_MATCH_2}") else() message(FATAL_ERROR "\${CMAKE_MATCH_1} is greater than \${CMAKE_MATCH_2}?") endif() # check less or equal (same as greater negative) case if(CMAKE_MATCH_1 VERSION_LESS_EQUAL CMAKE_MATCH_2) message(STATUS "\${CMAKE_MATCH_1} is not greater than \${CMAKE_MATCH_2}") else() message(FATAL_ERROR "\${CMAKE_MATCH_1} is greater than \${CMAKE_MATCH_2}?") endif() endforeach()
 ... ... @@ -106,11 +106,11 @@ macro(ADD_SECONDS sec) set(new_min \${\${GD_PREFIX}MINUTE}) set(new_hr \${\${GD_PREFIX}HOUR}) math(EXPR new_sec "\${sec} + \${\${GD_PREFIX}SECOND}") while(\${new_sec} GREATER 60 OR \${new_sec} EQUAL 60) while(\${new_sec} GREATER_EQUAL 60) math(EXPR new_sec "\${new_sec} - 60") math(EXPR new_min "\${\${GD_PREFIX}MINUTE} + 1") endwhile() while(\${new_min} GREATER 60 OR \${new_min} EQUAL 60) while(\${new_min} GREATER_EQUAL 60) math(EXPR new_min "\${new_min} - 60") math(EXPR new_hr "\${\${GD_PREFIX}HOUR} + 1") endwhile() ... ...
 ... ... @@ -92,6 +92,12 @@ endif() if(NOT 2.4 EQUAL 2.4) message(FATAL_ERROR "Failed: NOT 2.4 EQUAL 2.4") endif() if(NOT 2.4 LESS_EQUAL 2.4) message(FATAL_ERROR "Failed: NOT 2.4 LESS_EQUAL 2.4") endif() if(NOT 2.4 GREATER_EQUAL 2.4) message(FATAL_ERROR "Failed: NOT 2.4 GREATER_EQUAL 2.4") endif() if(CMAKE_SYSTEM MATCHES "OSF1-V") if(NOT CMAKE_COMPILER_IS_GNUCXX) ... ...
 ... ... @@ -455,7 +455,7 @@ int main() #endif #ifndef SHOULD_BE_DEFINED_LESS cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_LESS is not defined.\n"); cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_LESS is not defined."); #else cmPassed("SHOULD_BE_DEFINED_LESS is defined."); #endif ... ... @@ -467,7 +467,7 @@ int main() #endif #ifndef SHOULD_BE_DEFINED_LESS2 cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_LESS2 is not defined.\n"); cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_LESS2 is not defined."); #else cmPassed("SHOULD_BE_DEFINED_LESS2 is defined."); #endif ... ... @@ -478,6 +478,24 @@ int main() cmPassed("SHOULD_NOT_BE_DEFINED_GREATER is not defined."); #endif #ifndef SHOULD_BE_DEFINED_GREATER cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_GREATER is not defined."); #else cmPassed("SHOULD_BE_DEFINED_GREATER is defined."); #endif #ifdef SHOULD_NOT_BE_DEFINED_GREATER2 cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_GREATER2 is defined."); #else cmPassed("SHOULD_NOT_BE_DEFINED_GREATER2 is not defined."); #endif #ifndef SHOULD_BE_DEFINED_GREATER2 cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_GREATER2 is not defined."); #else cmPassed("SHOULD_BE_DEFINED_GREATER2 is defined."); #endif #ifdef SHOULD_NOT_BE_DEFINED_EQUAL cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_EQUAL is defined."); #else ... ... @@ -485,28 +503,93 @@ int main() #endif #ifndef SHOULD_BE_DEFINED_EQUAL cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_EQUAL is not defined.\n"); cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_EQUAL is not defined."); #else cmPassed("SHOULD_BE_DEFINED_EQUAL is defined."); #endif #ifndef SHOULD_BE_DEFINED_GREATER cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_GREATER is not defined.\n"); #ifdef SHOULD_NOT_BE_DEFINED_LESS_EQUAL cmFailed( "IF or SET is broken, SHOULD_NOT_BE_DEFINED_LESS_EQUAL is defined."); #else cmPassed("SHOULD_BE_DEFINED_GREATER is defined."); cmPassed("SHOULD_NOT_BE_DEFINED_LESS_EQUAL is not defined."); #endif #ifdef SHOULD_NOT_BE_DEFINED_GREATER2 cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_GREATER2 is defined."); #ifndef SHOULD_BE_DEFINED_LESS_EQUAL cmFailed( "IF or SET is broken, SHOULD_BE_DEFINED_LESS_EQUAL is not defined."); #else cmPassed("SHOULD_NOT_BE_DEFINED_GREATER2 is not defined."); cmPassed("SHOULD_BE_DEFINED_LESS_EQUAL is defined."); #endif #ifndef SHOULD_BE_DEFINED_GREATER2 #ifdef SHOULD_NOT_BE_DEFINED_LESS_EQUAL2 cmFailed( "IF or SET is broken, SHOULD_BE_DEFINED_GREATER2 is not defined.\n"); "IF or SET is broken, SHOULD_NOT_BE_DEFINED_LESS_EQUAL2 is defined."); #else cmPassed("SHOULD_BE_DEFINED_GREATER2 is defined."); cmPassed("SHOULD_NOT_BE_DEFINED_LESS_EQUAL2 is not defined."); #endif #ifndef SHOULD_BE_DEFINED_LESS_EQUAL2 cmFailed( "IF or SET is broken, SHOULD_BE_DEFINED_LESS_EQUAL2 is not defined."); #else cmPassed("SHOULD_BE_DEFINED_LESS_EQUAL2 is defined."); #endif #ifdef SHOULD_NOT_BE_DEFINED_LESS_EQUAL3 cmFailed( "IF or SET is broken, SHOULD_NOT_BE_DEFINED_LESS_EQUAL3 is defined."); #else cmPassed("SHOULD_NOT_BE_DEFINED_LESS_EQUAL3 is not defined."); #endif #ifndef SHOULD_BE_DEFINED_LESS_EQUAL3 cmFailed( "IF or SET is broken, SHOULD_BE_DEFINED_LESS_EQUAL3 is not defined."); #else cmPassed("SHOULD_BE_DEFINED_LESS_EQUAL3 is defined."); #endif #ifdef SHOULD_NOT_BE_DEFINED_GREATER_EQUAL cmFailed( "IF or SET is broken, SHOULD_NOT_BE_DEFINED_GREATER_EQUAL is defined."); #else cmPassed("SHOULD_NOT_BE_DEFINED_GREATER_EQUAL is not defined."); #endif #ifndef SHOULD_BE_DEFINED_GREATER_EQUAL cmFailed( "IF or SET is broken, SHOULD_BE_DEFINED_GREATER_EQUAL is not defined."); #else cmPassed("SHOULD_BE_DEFINED_GREATER_EQUAL is defined."); #endif #ifdef SHOULD_NOT_BE_DEFINED_GREATER_EQUAL2 cmFailed( "IF or SET is broken, SHOULD_NOT_BE_DEFINED_GREATER_EQUAL2 is defined."); #else cmPassed("SHOULD_NOT_BE_DEFINED_GREATER_EQUAL2 is not defined."); #endif #ifndef SHOULD_BE_DEFINED_GREATER_EQUAL2 cmFailed( "IF or SET is broken, SHOULD_BE_DEFINED_GREATER_EQUAL2 is not defined."); #else cmPassed("SHOULD_BE_DEFINED_GREATER_EQUAL2 is defined."); #endif #ifdef SHOULD_NOT_BE_DEFINED_GREATER_EQUAL3 cmFailed( "IF or SET is broken, SHOULD_NOT_BE_DEFINED_GREATER_EQUAL3 is defined."); #else cmPassed("SHOULD_NOT_BE_DEFINED_GREATER_EQUAL3 is not defined."); #endif