kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
CMake/Source/cmGeneratorExpressionEvalua...

2016 lines
69 KiB
C++
Raw Normal View History

cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2012 Stephen Kelly <steveire@gmail.com>
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 "cmMakefile.h"
#include "cmGeneratorExpressionEvaluator.h"
#include "cmGeneratorExpressionParser.h"
Add API to check that dependent target properties form a DAG. Initially this will only be used to check for self-references, but can be extended to check for cycles when chaining properties of other targets.
2012-09-18 15:42:23 +04:00
#include "cmGeneratorExpressionDAGChecker.h"
Add a self-reference check for target properties. Prevent constructs like: ... INCLUDE_DIRECTORIES "$<TARGET_PROPERTY:INCLUDE_DIRECTORIES>" Indirect self-references (cycles) are also prevented here, but indirect generator expression references of any kind are not possible yet anyway.
2012-09-18 15:53:39 +04:00
#include "cmGeneratorExpression.h"
Genex: Evaluate TARGET_OBJECTS as a normal expression.
2014-02-26 18:59:18 +04:00
#include "cmLocalGenerator.h"
#include "cmSourceFile.h"
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
GenEx: Use case insensitive comparison for $<CONFIG:...> This fixes a regression introduced by commit f1eacf0e (cmGeneratorExpression: Re-write for multi-stage evaluation).
2012-11-01 17:21:25 +04:00
#include <cmsys/String.h>
Don't crash when a target is expected but is not available.
2013-01-03 23:56:32 +04:00
#include <assert.h>
Genex: Add EQUAL expression. Support decimal, hex, octal and binary literals.
2013-12-27 15:42:37 +04:00
#include <errno.h>
Don't crash when a target is expected but is not available.
2013-01-03 23:56:32 +04:00
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
//----------------------------------------------------------------------------
Attempt to fix the compile of cmake on Sun CC. The problem may be that the reportError method is static, so make it non-static on that platform.
2012-10-12 00:31:35 +04:00
#if !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x510
static
#endif
void reportError(cmGeneratorExpressionContext *context,
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
const std::string &expr, const std::string &result)
{
context->HadError = true;
if (context->Quiet)
{
return;
}
cmOStringStream e;
e << "Error evaluating generator expression:\n"
<< " " << expr << "\n"
<< result;
context->Makefile->GetCMakeInstance()
Remove some c_str() calls. Use the clang RemoveCStrCalls tool to automatically migrate the code. This was only run on linux, so does not have any positive or negative effect on other platforms.
2014-03-11 03:04:11 +04:00
->IssueMessage(cmake::FATAL_ERROR, e.str(),
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
context->Backtrace);
}
//----------------------------------------------------------------------------
struct cmGeneratorExpressionNode
{
Add $<LINK_LANGUAGE> generator expression They can't be used when evaluating link libraries, but they can be used for include directories and compile definitions. Later they can be used for compile options.
2013-05-16 17:52:25 +04:00
enum {
DynamicParameters = 0,
OneOrMoreParameters = -1,
Genex: Reform error-checking for nullary/unary expressions. The error messages were incorrect (reporting that the expression requires one or two parameters), and repeated. Remove the now-unused ZeroOrMoreParameters enum value.
2013-12-31 17:28:52 +04:00
OneOrZeroParameters = -2
Add $<LINK_LANGUAGE> generator expression They can't be used when evaluating link libraries, but they can be used for include directories and compile definitions. Later they can be used for compile options.
2013-05-16 17:52:25 +04:00
};
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
virtual ~cmGeneratorExpressionNode() {}
virtual bool GeneratesContent() const { return true; }
Allow generator expressions to require literals.
2012-12-10 14:31:59 +04:00
virtual bool RequiresLiteralInput() const { return false; }
Rename the method determining if a genex accepts arbitrary content. The meaning of this will be expanded to generator expressions with more than a single parameter.
2013-04-25 15:28:57 +04:00
virtual bool AcceptsArbitraryContentParameter() const
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
{ return false; }
virtual int NumExpectedParameters() const { return 1; }
virtual std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *context,
Add API to check that dependent target properties form a DAG. Initially this will only be used to check for self-references, but can be extended to check for cycles when chaining properties of other targets.
2012-09-18 15:42:23 +04:00
const GeneratorExpressionContent *content,
cmGeneratorExpressionDAGChecker *dagChecker
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
) const = 0;
};
//----------------------------------------------------------------------------
static const struct ZeroNode : public cmGeneratorExpressionNode
{
ZeroNode() {}
virtual bool GeneratesContent() const { return false; }
Rename the method determining if a genex accepts arbitrary content. The meaning of this will be expanded to generator expressions with more than a single parameter.
2013-04-25 15:28:57 +04:00
virtual bool AcceptsArbitraryContentParameter() const { return true; }
Genex: Ensure that $<0:...> has a parameter.
2012-11-27 01:43:13 +04:00
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
std::string Evaluate(const std::vector<std::string> &,
cmGeneratorExpressionContext *,
Add API to check that dependent target properties form a DAG. Initially this will only be used to check for self-references, but can be extended to check for cycles when chaining properties of other targets.
2012-09-18 15:42:23 +04:00
const GeneratorExpressionContent *,
cmGeneratorExpressionDAGChecker *) const
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
{
return std::string();
}
} zeroNode;
//----------------------------------------------------------------------------
static const struct OneNode : public cmGeneratorExpressionNode
{
OneNode() {}
Rename the method determining if a genex accepts arbitrary content. The meaning of this will be expanded to generator expressions with more than a single parameter.
2013-04-25 15:28:57 +04:00
virtual bool AcceptsArbitraryContentParameter() const { return true; }
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
Genex: Allow single param expressions to accept arbirary input. Existing single-parameter expressions work due to special casing which assumes that if there is only one parameter, and the node accepts arbitrary content, then the result is the input. This is true for the existing expressions matching that pattern - namely the "1" and "TARGET_NAME" expressions. However, the LOWER_CASE, and UPPER_CASE expressions should also accept arbitrary content, and in their case, the result is not the input. Refactor the cmGeneratorExpressionEvaluator to allow that extension. Actually evaluate the "1" and "0" nodes.
2013-12-18 03:32:35 +04:00
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
cmGeneratorExpressionContext *,
Add API to check that dependent target properties form a DAG. Initially this will only be used to check for self-references, but can be extended to check for cycles when chaining properties of other targets.
2012-09-18 15:42:23 +04:00
const GeneratorExpressionContent *,
cmGeneratorExpressionDAGChecker *) const
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
{
Genex: Allow single param expressions to accept arbirary input. Existing single-parameter expressions work due to special casing which assumes that if there is only one parameter, and the node accepts arbitrary content, then the result is the input. This is true for the existing expressions matching that pattern - namely the "1" and "TARGET_NAME" expressions. However, the LOWER_CASE, and UPPER_CASE expressions should also accept arbitrary content, and in their case, the result is not the input. Refactor the cmGeneratorExpressionEvaluator to allow that extension. Actually evaluate the "1" and "0" nodes.
2013-12-18 03:32:35 +04:00
return parameters.front();
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
}
} oneNode;
GenEx: Add expressions to specify build- or install-only values This is for specifying INCLUDE_DIRECTORIES relevant to the build-location or the install location for example: set_property(TARGET foo PROPERTY INTERFACE_INCLUDE_DIRECTORIES "$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR};${CMAKE_CURRENT_SOURCE_DIR}>" "$<INSTALL_INTERFACE:${CMAKE_INSTALL_PREFIX}/include>" ) A 'bar' target can then use: set_property(TARGET bar PROPERTY INCLUDE_DIRECTORIES "$<TARGET_PROPERTY:foo,INTERFACE_INCLUDE_DIRECTORIES>" ) and it will work whether foo is in the same project, or an imported target from an installation location, or an imported target from a build location generated by the export() command. Because the generator expressions are only evaluated at build-time, these new expressions are equivalent to the ZeroNode and OneNode. The GeneratorExpression test is split into parts. Some shells can't run the custom command as it is getting too long.
2012-09-23 15:16:44 +04:00
//----------------------------------------------------------------------------
static const struct OneNode buildInterfaceNode;
//----------------------------------------------------------------------------
static const struct ZeroNode installInterfaceNode;
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
//----------------------------------------------------------------------------
#define BOOLEAN_OP_NODE(OPNAME, OP, SUCCESS_VALUE, FAILURE_VALUE) \
static const struct OP ## Node : public cmGeneratorExpressionNode \
{ \
OP ## Node () {} \
Add $<LINK_LANGUAGE> generator expression They can't be used when evaluating link libraries, but they can be used for include directories and compile definitions. Later they can be used for compile options.
2013-05-16 17:52:25 +04:00
virtual int NumExpectedParameters() const { return OneOrMoreParameters; } \
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
\
std::string Evaluate(const std::vector<std::string> &parameters, \
cmGeneratorExpressionContext *context, \
Add API to check that dependent target properties form a DAG. Initially this will only be used to check for self-references, but can be extended to check for cycles when chaining properties of other targets.
2012-09-18 15:42:23 +04:00
const GeneratorExpressionContent *content, \
cmGeneratorExpressionDAGChecker *) const \
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
{ \
std::vector<std::string>::const_iterator it = parameters.begin(); \
const std::vector<std::string>::const_iterator end = parameters.end(); \
for ( ; it != end; ++it) \
{ \
if (*it == #FAILURE_VALUE) \
{ \
return #FAILURE_VALUE; \
} \
else if (*it != #SUCCESS_VALUE) \
{ \
reportError(context, content->GetOriginalExpression(), \
"Parameters to $<" #OP "> must resolve to either '0' or '1'."); \
return std::string(); \
} \
} \
return #SUCCESS_VALUE; \
} \
} OPNAME;
BOOLEAN_OP_NODE(andNode, AND, 1, 0)
BOOLEAN_OP_NODE(orNode, OR, 0, 1)
#undef BOOLEAN_OP_NODE
//----------------------------------------------------------------------------
static const struct NotNode : public cmGeneratorExpressionNode
{
NotNode() {}
Add API to check that dependent target properties form a DAG. Initially this will only be used to check for self-references, but can be extended to check for cycles when chaining properties of other targets.
2012-09-18 15:42:23 +04:00
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *context,
Add API to check that dependent target properties form a DAG. Initially this will only be used to check for self-references, but can be extended to check for cycles when chaining properties of other targets.
2012-09-18 15:42:23 +04:00
const GeneratorExpressionContent *content,
cmGeneratorExpressionDAGChecker *) const
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
{
if (*parameters.begin() != "0" && *parameters.begin() != "1")
{
reportError(context, content->GetOriginalExpression(),
"$<NOT> parameter must resolve to exactly one '0' or '1' value.");
return std::string();
}
return *parameters.begin() == "0" ? "1" : "0";
}
} notNode;
Extend the generator expression language with more logic. Generator expressions for comparing strings, evaluating strings as booleans, and for creating literal right-angle-brackets and commas are added. Those may be needed in some cases where they appear in literals.
2012-09-12 06:20:42 +04:00
//----------------------------------------------------------------------------
static const struct BoolNode : public cmGeneratorExpressionNode
{
BoolNode() {}
virtual int NumExpectedParameters() const { return 1; }
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *,
Add API to check that dependent target properties form a DAG. Initially this will only be used to check for self-references, but can be extended to check for cycles when chaining properties of other targets.
2012-09-18 15:42:23 +04:00
const GeneratorExpressionContent *,
cmGeneratorExpressionDAGChecker *) const
Extend the generator expression language with more logic. Generator expressions for comparing strings, evaluating strings as booleans, and for creating literal right-angle-brackets and commas are added. Those may be needed in some cases where they appear in literals.
2012-09-12 06:20:42 +04:00
{
return !cmSystemTools::IsOff(parameters.begin()->c_str()) ? "1" : "0";
}
} boolNode;
//----------------------------------------------------------------------------
static const struct StrEqualNode : public cmGeneratorExpressionNode
{
StrEqualNode() {}
virtual int NumExpectedParameters() const { return 2; }
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *,
Add API to check that dependent target properties form a DAG. Initially this will only be used to check for self-references, but can be extended to check for cycles when chaining properties of other targets.
2012-09-18 15:42:23 +04:00
const GeneratorExpressionContent *,
cmGeneratorExpressionDAGChecker *) const
Extend the generator expression language with more logic. Generator expressions for comparing strings, evaluating strings as booleans, and for creating literal right-angle-brackets and commas are added. Those may be needed in some cases where they appear in literals.
2012-09-12 06:20:42 +04:00
{
GenEx: Don't use std::vector::at(int). It might not exist with GCC 2.9.
2012-10-04 13:21:05 +04:00
return *parameters.begin() == parameters[1] ? "1" : "0";
Extend the generator expression language with more logic. Generator expressions for comparing strings, evaluating strings as booleans, and for creating literal right-angle-brackets and commas are added. Those may be needed in some cases where they appear in literals.
2012-09-12 06:20:42 +04:00
}
} strEqualNode;
Genex: Add EQUAL expression. Support decimal, hex, octal and binary literals.
2013-12-27 15:42:37 +04:00
//----------------------------------------------------------------------------
static const struct EqualNode : public cmGeneratorExpressionNode
{
EqualNode() {}
virtual int NumExpectedParameters() const { return 2; }
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *context,
const GeneratorExpressionContent *content,
cmGeneratorExpressionDAGChecker *) const
{
char *pEnd;
int base = 0;
bool flipSign = false;
const char *lhs = parameters[0].c_str();
Genex: Make EQUAL support upper case binary literals As C++11, python, D and java do. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3472.pdf Add test for uppercase hex literals.
2014-01-04 22:38:23 +04:00
if (cmHasLiteralPrefix(lhs, "0b") || cmHasLiteralPrefix(lhs, "0B"))
Genex: Add EQUAL expression. Support decimal, hex, octal and binary literals.
2013-12-27 15:42:37 +04:00
{
base = 2;
lhs += 2;
}
Genex: Make EQUAL support upper case binary literals As C++11, python, D and java do. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3472.pdf Add test for uppercase hex literals.
2014-01-04 22:38:23 +04:00
if (cmHasLiteralPrefix(lhs, "-0b") || cmHasLiteralPrefix(lhs, "-0B"))
Genex: Add EQUAL expression. Support decimal, hex, octal and binary literals.
2013-12-27 15:42:37 +04:00
{
base = 2;
lhs += 3;
flipSign = true;
}
Genex: Make EQUAL support upper case binary literals As C++11, python, D and java do. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3472.pdf Add test for uppercase hex literals.
2014-01-04 22:38:23 +04:00
if (cmHasLiteralPrefix(lhs, "+0b") || cmHasLiteralPrefix(lhs, "+0B"))
Genex: Add EQUAL expression. Support decimal, hex, octal and binary literals.
2013-12-27 15:42:37 +04:00
{
base = 2;
lhs += 3;
}
long lnum = strtol(lhs, &pEnd, base);
if (pEnd == lhs || *pEnd != '\0' || errno == ERANGE)
{
reportError(context, content->GetOriginalExpression(),
"$<EQUAL> parameter " + parameters[0] + " is not a valid integer.");
return std::string();
}
if (flipSign)
{
lnum = -lnum;
}
base = 0;
flipSign = false;
const char *rhs = parameters[1].c_str();
Genex: Make EQUAL support upper case binary literals As C++11, python, D and java do. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3472.pdf Add test for uppercase hex literals.
2014-01-04 22:38:23 +04:00
if (cmHasLiteralPrefix(rhs, "0b") || cmHasLiteralPrefix(rhs, "0B"))
Genex: Add EQUAL expression. Support decimal, hex, octal and binary literals.
2013-12-27 15:42:37 +04:00
{
base = 2;
rhs += 2;
}
Genex: Make EQUAL support upper case binary literals As C++11, python, D and java do. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3472.pdf Add test for uppercase hex literals.
2014-01-04 22:38:23 +04:00
if (cmHasLiteralPrefix(rhs, "-0b") || cmHasLiteralPrefix(rhs, "-0B"))
Genex: Add EQUAL expression. Support decimal, hex, octal and binary literals.
2013-12-27 15:42:37 +04:00
{
base = 2;
rhs += 3;
flipSign = true;
}
Genex: Make EQUAL support upper case binary literals As C++11, python, D and java do. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3472.pdf Add test for uppercase hex literals.
2014-01-04 22:38:23 +04:00
if (cmHasLiteralPrefix(rhs, "+0b") || cmHasLiteralPrefix(rhs, "+0B"))
Genex: Add EQUAL expression. Support decimal, hex, octal and binary literals.
2013-12-27 15:42:37 +04:00
{
base = 2;
rhs += 3;
}
long rnum = strtol(rhs, &pEnd, base);
if (pEnd == rhs || *pEnd != '\0' || errno == ERANGE)
{
reportError(context, content->GetOriginalExpression(),
"$<EQUAL> parameter " + parameters[1] + " is not a valid integer.");
return std::string();
}
if (flipSign)
{
rnum = -rnum;
}
return lnum == rnum ? "1" : "0";
}
} equalNode;
Genex: Add {UPPER,LOWER}_CASE and MAKE_C_IDENTIFIER.
2013-11-21 00:40:29 +04:00
//----------------------------------------------------------------------------
static const struct LowerCaseNode : public cmGeneratorExpressionNode
{
LowerCaseNode() {}
Genex: Accept arbitrary content in *_CASE and MAKE_C_IDENTIFIER.
2013-12-15 14:02:56 +04:00
bool AcceptsArbitraryContentParameter() const { return true; }
Genex: Add {UPPER,LOWER}_CASE and MAKE_C_IDENTIFIER.
2013-11-21 00:40:29 +04:00
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *,
const GeneratorExpressionContent *,
cmGeneratorExpressionDAGChecker *) const
{
return cmSystemTools::LowerCase(parameters.front());
}
} lowerCaseNode;
//----------------------------------------------------------------------------
static const struct UpperCaseNode : public cmGeneratorExpressionNode
{
UpperCaseNode() {}
Genex: Accept arbitrary content in *_CASE and MAKE_C_IDENTIFIER.
2013-12-15 14:02:56 +04:00
bool AcceptsArbitraryContentParameter() const { return true; }
Genex: Add {UPPER,LOWER}_CASE and MAKE_C_IDENTIFIER.
2013-11-21 00:40:29 +04:00
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *,
const GeneratorExpressionContent *,
cmGeneratorExpressionDAGChecker *) const
{
return cmSystemTools::UpperCase(parameters.front());
}
} upperCaseNode;
//----------------------------------------------------------------------------
static const struct MakeCIdentifierNode : public cmGeneratorExpressionNode
{
MakeCIdentifierNode() {}
Genex: Accept arbitrary content in *_CASE and MAKE_C_IDENTIFIER.
2013-12-15 14:02:56 +04:00
bool AcceptsArbitraryContentParameter() const { return true; }
Genex: Add {UPPER,LOWER}_CASE and MAKE_C_IDENTIFIER.
2013-11-21 00:40:29 +04:00
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *,
const GeneratorExpressionContent *,
cmGeneratorExpressionDAGChecker *) const
{
return cmSystemTools::MakeCidentifier(parameters.front().c_str());
}
} makeCIdentifierNode;
Extend the generator expression language with more logic. Generator expressions for comparing strings, evaluating strings as booleans, and for creating literal right-angle-brackets and commas are added. Those may be needed in some cases where they appear in literals.
2012-09-12 06:20:42 +04:00
//----------------------------------------------------------------------------
static const struct Angle_RNode : public cmGeneratorExpressionNode
{
Angle_RNode() {}
virtual int NumExpectedParameters() const { return 0; }
std::string Evaluate(const std::vector<std::string> &,
cmGeneratorExpressionContext *,
Add API to check that dependent target properties form a DAG. Initially this will only be used to check for self-references, but can be extended to check for cycles when chaining properties of other targets.
2012-09-18 15:42:23 +04:00
const GeneratorExpressionContent *,
cmGeneratorExpressionDAGChecker *) const
Extend the generator expression language with more logic. Generator expressions for comparing strings, evaluating strings as booleans, and for creating literal right-angle-brackets and commas are added. Those may be needed in some cases where they appear in literals.
2012-09-12 06:20:42 +04:00
{
return ">";
}
} angle_rNode;
//----------------------------------------------------------------------------
static const struct CommaNode : public cmGeneratorExpressionNode
{
CommaNode() {}
virtual int NumExpectedParameters() const { return 0; }
std::string Evaluate(const std::vector<std::string> &,
cmGeneratorExpressionContext *,
Add API to check that dependent target properties form a DAG. Initially this will only be used to check for self-references, but can be extended to check for cycles when chaining properties of other targets.
2012-09-18 15:42:23 +04:00
const GeneratorExpressionContent *,
cmGeneratorExpressionDAGChecker *) const
Extend the generator expression language with more logic. Generator expressions for comparing strings, evaluating strings as booleans, and for creating literal right-angle-brackets and commas are added. Those may be needed in some cases where they appear in literals.
2012-09-12 06:20:42 +04:00
{
return ",";
}
} commaNode;
Add $<SEMICOLON> generator expression. This expression is useful to put a ';' in a command line argument without dividing the argument during CMake list expansion.
2013-03-12 10:52:01 +04:00
//----------------------------------------------------------------------------
static const struct SemicolonNode : public cmGeneratorExpressionNode
{
SemicolonNode() {}
virtual int NumExpectedParameters() const { return 0; }
std::string Evaluate(const std::vector<std::string> &,
cmGeneratorExpressionContext *,
const GeneratorExpressionContent *,
cmGeneratorExpressionDAGChecker *) const
{
return ";";
}
} semicolonNode;
Add <LANG>_COMPILER_ID generator expressions. These expressions evaluate to the id of the compiler used to build the target, or can be used to test if the compiler id matches a specified value.
2013-05-28 14:17:25 +04:00
//----------------------------------------------------------------------------
struct CompilerIdNode : public cmGeneratorExpressionNode
{
CompilerIdNode() {}
Genex: Reform error-checking for nullary/unary expressions. The error messages were incorrect (reporting that the expression requires one or two parameters), and repeated. Remove the now-unused ZeroOrMoreParameters enum value.
2013-12-31 17:28:52 +04:00
virtual int NumExpectedParameters() const { return OneOrZeroParameters; }
Add <LANG>_COMPILER_ID generator expressions. These expressions evaluate to the id of the compiler used to build the target, or can be used to test if the compiler id matches a specified value.
2013-05-28 14:17:25 +04:00
std::string EvaluateWithLanguage(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *context,
const GeneratorExpressionContent *content,
cmGeneratorExpressionDAGChecker *,
const std::string &lang) const
{
const char *compilerId = context->Makefile ?
Remove some c_str() calls. Use the clang RemoveCStrCalls tool to automatically migrate the code. This was only run on linux, so does not have any positive or negative effect on other platforms.
2014-03-11 03:04:11 +04:00
context->Makefile->GetSafeDefinition(
"CMAKE_" + lang + "_COMPILER_ID") : "";
Add <LANG>_COMPILER_ID generator expressions. These expressions evaluate to the id of the compiler used to build the target, or can be used to test if the compiler id matches a specified value.
2013-05-28 14:17:25 +04:00
if (parameters.size() == 0)
{
return compilerId ? compilerId : "";
}
regex: Use static regexs where possible Rather than declaring and compiling a constant regex every time a chunk of code is executed, build the regex once.
2014-04-30 21:12:29 +04:00
static cmsys::RegularExpression compilerIdValidator("^[A-Za-z0-9_]*$");
regex: Search on strings where possible
2014-04-30 21:13:21 +04:00
if (!compilerIdValidator.find(*parameters.begin()))
Add <LANG>_COMPILER_ID generator expressions. These expressions evaluate to the id of the compiler used to build the target, or can be used to test if the compiler id matches a specified value.
2013-05-28 14:17:25 +04:00
{
reportError(context, content->GetOriginalExpression(),
"Expression syntax not recognized.");
return std::string();
}
if (!compilerId)
{
return parameters.front().empty() ? "1" : "0";
}
Genex: Use case-sensitive comparison for COMPILER_ID.
2013-12-26 18:59:55 +04:00
if (strcmp(parameters.begin()->c_str(), compilerId) == 0)
Add <LANG>_COMPILER_ID generator expressions. These expressions evaluate to the id of the compiler used to build the target, or can be used to test if the compiler id matches a specified value.
2013-05-28 14:17:25 +04:00
{
return "1";
}
Genex: Use case-sensitive comparison for COMPILER_ID.
2013-12-26 18:59:55 +04:00
if (cmsysString_strcasecmp(parameters.begin()->c_str(), compilerId) == 0)
{
switch(context->Makefile->GetPolicyStatus(cmPolicies::CMP0044))
{
case cmPolicies::WARN:
{
cmOStringStream e;
e << context->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0044);
context->Makefile->GetCMakeInstance()
->IssueMessage(cmake::AUTHOR_WARNING,
Remove some c_str() calls. Use the clang RemoveCStrCalls tool to automatically migrate the code. This was only run on linux, so does not have any positive or negative effect on other platforms.
2014-03-11 03:04:11 +04:00
e.str(), context->Backtrace);
Genex: Use case-sensitive comparison for COMPILER_ID.
2013-12-26 18:59:55 +04:00
}
case cmPolicies::OLD:
return "1";
case cmPolicies::NEW:
case cmPolicies::REQUIRED_ALWAYS:
case cmPolicies::REQUIRED_IF_USED:
break;
}
}
Add <LANG>_COMPILER_ID generator expressions. These expressions evaluate to the id of the compiler used to build the target, or can be used to test if the compiler id matches a specified value.
2013-05-28 14:17:25 +04:00
return "0";
}
};
//----------------------------------------------------------------------------
static const struct CCompilerIdNode : public CompilerIdNode
{
CCompilerIdNode() {}
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *context,
const GeneratorExpressionContent *content,
cmGeneratorExpressionDAGChecker *dagChecker) const
{
if (!context->HeadTarget)
{
reportError(context, content->GetOriginalExpression(),
Genex: Clarify error message on use with non-binary targets (#14899).
2014-05-29 00:02:57 +04:00
"$<C_COMPILER_ID> may only be used with binary targets. It may "
"not be used with add_custom_command or add_custom_target.");
Genex: Always return immediately on error.
2013-12-18 21:47:37 +04:00
return std::string();
Add <LANG>_COMPILER_ID generator expressions. These expressions evaluate to the id of the compiler used to build the target, or can be used to test if the compiler id matches a specified value.
2013-05-28 14:17:25 +04:00
}
return this->EvaluateWithLanguage(parameters, context, content,
dagChecker, "C");
}
} cCompilerIdNode;
//----------------------------------------------------------------------------
static const struct CXXCompilerIdNode : public CompilerIdNode
{
CXXCompilerIdNode() {}
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *context,
const GeneratorExpressionContent *content,
cmGeneratorExpressionDAGChecker *dagChecker) const
{
if (!context->HeadTarget)
{
reportError(context, content->GetOriginalExpression(),
Genex: Clarify error message on use with non-binary targets (#14899).
2014-05-29 00:02:57 +04:00
"$<CXX_COMPILER_ID> may only be used with binary targets. It may "
"not be used with add_custom_command or add_custom_target.");
Genex: Always return immediately on error.
2013-12-18 21:47:37 +04:00
return std::string();
Add <LANG>_COMPILER_ID generator expressions. These expressions evaluate to the id of the compiler used to build the target, or can be used to test if the compiler id matches a specified value.
2013-05-28 14:17:25 +04:00
}
return this->EvaluateWithLanguage(parameters, context, content,
dagChecker, "CXX");
}
} cxxCompilerIdNode;
Add generator expressions for compiler versions. New generator expressions allow retrieval of the version per language, as well as equality comparison.
2013-06-11 12:48:47 +04:00
//----------------------------------------------------------------------------
struct CompilerVersionNode : public cmGeneratorExpressionNode
{
CompilerVersionNode() {}
Genex: Reform error-checking for nullary/unary expressions. The error messages were incorrect (reporting that the expression requires one or two parameters), and repeated. Remove the now-unused ZeroOrMoreParameters enum value.
2013-12-31 17:28:52 +04:00
virtual int NumExpectedParameters() const { return OneOrZeroParameters; }
Add generator expressions for compiler versions. New generator expressions allow retrieval of the version per language, as well as equality comparison.
2013-06-11 12:48:47 +04:00
std::string EvaluateWithLanguage(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *context,
const GeneratorExpressionContent *content,
cmGeneratorExpressionDAGChecker *,
const std::string &lang) const
{
const char *compilerVersion = context->Makefile ?
Remove some c_str() calls. Use the clang RemoveCStrCalls tool to automatically migrate the code. This was only run on linux, so does not have any positive or negative effect on other platforms.
2014-03-11 03:04:11 +04:00
context->Makefile->GetSafeDefinition(
"CMAKE_" + lang + "_COMPILER_VERSION") : "";
Add generator expressions for compiler versions. New generator expressions allow retrieval of the version per language, as well as equality comparison.
2013-06-11 12:48:47 +04:00
if (parameters.size() == 0)
{
return compilerVersion ? compilerVersion : "";
}
regex: Use static regexs where possible Rather than declaring and compiling a constant regex every time a chunk of code is executed, build the regex once.
2014-04-30 21:12:29 +04:00
static cmsys::RegularExpression compilerIdValidator("^[0-9\\.]*$");
regex: Search on strings where possible
2014-04-30 21:13:21 +04:00
if (!compilerIdValidator.find(*parameters.begin()))
Add generator expressions for compiler versions. New generator expressions allow retrieval of the version per language, as well as equality comparison.
2013-06-11 12:48:47 +04:00
{
reportError(context, content->GetOriginalExpression(),
"Expression syntax not recognized.");
return std::string();
}
if (!compilerVersion)
{
return parameters.front().empty() ? "1" : "0";
}
return cmSystemTools::VersionCompare(cmSystemTools::OP_EQUAL,
parameters.begin()->c_str(),
compilerVersion) ? "1" : "0";
}
};
//----------------------------------------------------------------------------
static const struct CCompilerVersionNode : public CompilerVersionNode
{
CCompilerVersionNode() {}
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *context,
const GeneratorExpressionContent *content,
cmGeneratorExpressionDAGChecker *dagChecker) const
{
if (!context->HeadTarget)
{
reportError(context, content->GetOriginalExpression(),
Genex: Clarify error message on use with non-binary targets (#14899).
2014-05-29 00:02:57 +04:00
"$<C_COMPILER_VERSION> may only be used with binary targets. It "
"may not be used with add_custom_command or add_custom_target.");
Genex: Always return immediately on error.
2013-12-18 21:47:37 +04:00
return std::string();
Add generator expressions for compiler versions. New generator expressions allow retrieval of the version per language, as well as equality comparison.
2013-06-11 12:48:47 +04:00
}
return this->EvaluateWithLanguage(parameters, context, content,
dagChecker, "C");
}
} cCompilerVersionNode;
//----------------------------------------------------------------------------
static const struct CxxCompilerVersionNode : public CompilerVersionNode
{
CxxCompilerVersionNode() {}
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *context,
const GeneratorExpressionContent *content,
cmGeneratorExpressionDAGChecker *dagChecker) const
{
if (!context->HeadTarget)
{
reportError(context, content->GetOriginalExpression(),
Genex: Clarify error message on use with non-binary targets (#14899).
2014-05-29 00:02:57 +04:00
"$<CXX_COMPILER_VERSION> may only be used with binary targets. It "
"may not be used with add_custom_command or add_custom_target.");
Genex: Always return immediately on error.
2013-12-18 21:47:37 +04:00
return std::string();
Add generator expressions for compiler versions. New generator expressions allow retrieval of the version per language, as well as equality comparison.
2013-06-11 12:48:47 +04:00
}
return this->EvaluateWithLanguage(parameters, context, content,
dagChecker, "CXX");
}
} cxxCompilerVersionNode;
Genex: Add the PLATFORM_ID expression.
2013-08-27 12:57:16 +04:00
//----------------------------------------------------------------------------
struct PlatformIdNode : public cmGeneratorExpressionNode
{
PlatformIdNode() {}
Genex: Reform error-checking for nullary/unary expressions. The error messages were incorrect (reporting that the expression requires one or two parameters), and repeated. Remove the now-unused ZeroOrMoreParameters enum value.
2013-12-31 17:28:52 +04:00
virtual int NumExpectedParameters() const { return OneOrZeroParameters; }
Genex: Add the PLATFORM_ID expression.
2013-08-27 12:57:16 +04:00
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *context,
const GeneratorExpressionContent *,
cmGeneratorExpressionDAGChecker *) const
{
const char *platformId = context->Makefile ?
context->Makefile->GetSafeDefinition(
"CMAKE_SYSTEM_NAME") : "";
if (parameters.size() == 0)
{
return platformId ? platformId : "";
}
if (!platformId)
{
return parameters.front().empty() ? "1" : "0";
}
Genex: Use case-sensitive comparison in PLATFORM_ID.
2013-12-18 21:48:07 +04:00
if (strcmp(parameters.begin()->c_str(), platformId) == 0)
Genex: Add the PLATFORM_ID expression.
2013-08-27 12:57:16 +04:00
{
return "1";
}
return "0";
}
} platformIdNode;
Add generator expressions for version comparision.
2013-06-11 11:53:10 +04:00
//----------------------------------------------------------------------------
static const struct VersionGreaterNode : public cmGeneratorExpressionNode
{
VersionGreaterNode() {}
virtual int NumExpectedParameters() const { return 2; }
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *,
const GeneratorExpressionContent *,
cmGeneratorExpressionDAGChecker *) const
{
return cmSystemTools::VersionCompare(cmSystemTools::OP_GREATER,
parameters.front().c_str(),
parameters[1].c_str()) ? "1" : "0";
}
} versionGreaterNode;
//----------------------------------------------------------------------------
static const struct VersionLessNode : public cmGeneratorExpressionNode
{
VersionLessNode() {}
virtual int NumExpectedParameters() const { return 2; }
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *,
const GeneratorExpressionContent *,
cmGeneratorExpressionDAGChecker *) const
{
return cmSystemTools::VersionCompare(cmSystemTools::OP_LESS,
parameters.front().c_str(),
parameters[1].c_str()) ? "1" : "0";
}
} versionLessNode;
//----------------------------------------------------------------------------
static const struct VersionEqualNode : public cmGeneratorExpressionNode
{
VersionEqualNode() {}
virtual int NumExpectedParameters() const { return 2; }
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *,
const GeneratorExpressionContent *,
cmGeneratorExpressionDAGChecker *) const
{
return cmSystemTools::VersionCompare(cmSystemTools::OP_EQUAL,
parameters.front().c_str(),
parameters[1].c_str()) ? "1" : "0";
}
} versionEqualNode;
Introduce the LINK_ONLY generator expression. This is an internal expression for use by target_link_libraries for static libraries.
2013-06-05 15:43:54 +04:00
//----------------------------------------------------------------------------
static const struct LinkOnlyNode : public cmGeneratorExpressionNode
{
LinkOnlyNode() {}
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *,
const GeneratorExpressionContent *,
cmGeneratorExpressionDAGChecker *dagChecker) const
{
if(!dagChecker->GetTransitivePropertiesOnly())
{
return parameters.front();
}
return "";
}
} linkOnlyNode;
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
//----------------------------------------------------------------------------
static const struct ConfigurationNode : public cmGeneratorExpressionNode
{
ConfigurationNode() {}
Add API to check that dependent target properties form a DAG. Initially this will only be used to check for self-references, but can be extended to check for cycles when chaining properties of other targets.
2012-09-18 15:42:23 +04:00
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
virtual int NumExpectedParameters() const { return 0; }
std::string Evaluate(const std::vector<std::string> &,
cmGeneratorExpressionContext *context,
Add API to check that dependent target properties form a DAG. Initially this will only be used to check for self-references, but can be extended to check for cycles when chaining properties of other targets.
2012-09-18 15:42:23 +04:00
const GeneratorExpressionContent *,
cmGeneratorExpressionDAGChecker *) const
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
{
Cache context-independent includes on evaluation. Generator expressions whose output depends on the configuration now record that fact. The GetIncludeDirectories method can use that result to cache the include directories for later calls. GetIncludeDirectories is called multiple times for a target for each configuration, so this should restore performance for multi-config generators.
2013-02-03 10:33:15 +04:00
context->HadContextSensitiveCondition = true;
stringapi: Pass configuration names as strings
2014-02-10 07:48:34 +04:00
return context->Config;
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
}
} configurationNode;
//----------------------------------------------------------------------------
static const struct ConfigurationTestNode : public cmGeneratorExpressionNode
{
ConfigurationTestNode() {}
Genex: Add a nullary form for CONFIG This is consistent with other similar expressions such as PLATFORM_ID, and makes the CONFIGURATION expression obsolete. Fix an off-by-one error in GeneratorExpressionContent::EvaluateParameters exposed by a unit test. Remove the test for 'bad' nullary use of $<CONFIG>. Add a unit test to verify that $<CONFIG> and $<CONFIGURATION> have the same value.
2013-12-31 18:57:25 +04:00
virtual int NumExpectedParameters() const { return OneOrZeroParameters; }
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *context,
Add API to check that dependent target properties form a DAG. Initially this will only be used to check for self-references, but can be extended to check for cycles when chaining properties of other targets.
2012-09-18 15:42:23 +04:00
const GeneratorExpressionContent *content,
cmGeneratorExpressionDAGChecker *) const
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
{
Genex: Add a nullary form for CONFIG This is consistent with other similar expressions such as PLATFORM_ID, and makes the CONFIGURATION expression obsolete. Fix an off-by-one error in GeneratorExpressionContent::EvaluateParameters exposed by a unit test. Remove the test for 'bad' nullary use of $<CONFIG>. Add a unit test to verify that $<CONFIG> and $<CONFIGURATION> have the same value.
2013-12-31 18:57:25 +04:00
if (parameters.empty())
{
return configurationNode.Evaluate(parameters, context, content, 0);
}
regex: Use static regexs where possible Rather than declaring and compiling a constant regex every time a chunk of code is executed, build the regex once.
2014-04-30 21:12:29 +04:00
static cmsys::RegularExpression configValidator("^[A-Za-z0-9_]*$");
regex: Search on strings where possible
2014-04-30 21:13:21 +04:00
if (!configValidator.find(*parameters.begin()))
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
{
reportError(context, content->GetOriginalExpression(),
"Expression syntax not recognized.");
return std::string();
}
Cache context-independent includes on evaluation. Generator expressions whose output depends on the configuration now record that fact. The GetIncludeDirectories method can use that result to cache the include directories for later calls. GetIncludeDirectories is called multiple times for a target for each configuration, so this should restore performance for multi-config generators.
2013-02-03 10:33:15 +04:00
context->HadContextSensitiveCondition = true;
stringapi: Pass configuration names as strings
2014-02-10 07:48:34 +04:00
if (context->Config.empty())
GenEx: Ensure that the empty CONFIGURATION can be used conditionally. The CONFIGURATION can not be manipulated at unit testing time, so this is not unit tested further.
2012-10-04 02:36:23 +04:00
{
return parameters.front().empty() ? "1" : "0";
}
Use mapped config properties to evaluate $<CONFIG>
2012-12-23 14:20:37 +04:00
if (cmsysString_strcasecmp(parameters.begin()->c_str(),
stringapi: Pass configuration names as strings
2014-02-10 07:48:34 +04:00
context->Config.c_str()) == 0)
Use mapped config properties to evaluate $<CONFIG>
2012-12-23 14:20:37 +04:00
{
return "1";
}
if (context->CurrentTarget
&& context->CurrentTarget->IsImported())
{
const char* loc = 0;
const char* imp = 0;
std::string suffix;
Genex: Fix $<CONFIG> with IMPORTED targets and multiple locations. The old code checked only that there was a LOCATION for the specified config, but did not check whether the config actually mapped. Task-number: 14292
2013-07-15 20:33:49 +04:00
if (context->CurrentTarget->GetMappedConfig(context->Config,
Use mapped config properties to evaluate $<CONFIG>
2012-12-23 14:20:37 +04:00
&loc,
&imp,
Genex: Fix $<CONFIG> with IMPORTED targets and multiple locations. The old code checked only that there was a LOCATION for the specified config, but did not check whether the config actually mapped. Task-number: 14292
2013-07-15 20:33:49 +04:00
suffix))
{
// This imported target has an appropriate location
// for this (possibly mapped) config.
// Check if there is a proper config mapping for the tested config.
std::vector<std::string> mappedConfigs;
std::string mapProp = "MAP_IMPORTED_CONFIG_";
Genex: Fix evaluation of MAP_IMPORTED_CONFIG_<CONFIG> Commit 10a069b5 (Genex: Fix $<CONFIG> with IMPORTED targets and multiple locations., 2013-07-15) changed the logic here to include handling of the MAP_IMPORTED_CONFIG_<CONFIG> target property, but it was buggy in several ways. Uppercase the configs in all cases, and compare the mapped configs with the parameter to the CONFIG genex, instead of with the key of the mapping.
2013-08-27 17:36:57 +04:00
mapProp += cmSystemTools::UpperCase(context->Config);
Genex: Fix $<CONFIG> with IMPORTED targets and multiple locations. The old code checked only that there was a LOCATION for the specified config, but did not check whether the config actually mapped. Task-number: 14292
2013-07-15 20:33:49 +04:00
if(const char* mapValue =
Remove some c_str() calls. Use the clang RemoveCStrCalls tool to automatically migrate the code. This was only run on linux, so does not have any positive or negative effect on other platforms.
2014-03-11 03:04:11 +04:00
context->CurrentTarget->GetProperty(mapProp))
Genex: Fix $<CONFIG> with IMPORTED targets and multiple locations. The old code checked only that there was a LOCATION for the specified config, but did not check whether the config actually mapped. Task-number: 14292
2013-07-15 20:33:49 +04:00
{
cmSystemTools::ExpandListArgument(cmSystemTools::UpperCase(mapValue),
mappedConfigs);
return std::find(mappedConfigs.begin(), mappedConfigs.end(),
Genex: Fix evaluation of MAP_IMPORTED_CONFIG_<CONFIG> Commit 10a069b5 (Genex: Fix $<CONFIG> with IMPORTED targets and multiple locations., 2013-07-15) changed the logic here to include handling of the MAP_IMPORTED_CONFIG_<CONFIG> target property, but it was buggy in several ways. Uppercase the configs in all cases, and compare the mapped configs with the parameter to the CONFIG genex, instead of with the key of the mapping.
2013-08-27 17:36:57 +04:00
cmSystemTools::UpperCase(parameters.front()))
!= mappedConfigs.end() ? "1" : "0";
Genex: Fix $<CONFIG> with IMPORTED targets and multiple locations. The old code checked only that there was a LOCATION for the specified config, but did not check whether the config actually mapped. Task-number: 14292
2013-07-15 20:33:49 +04:00
}
}
Use mapped config properties to evaluate $<CONFIG>
2012-12-23 14:20:37 +04:00
}
return "0";
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
}
} configurationTestNode;
Add the JOIN generator expression. This generator expression joins a list with a separator. The separator may contain arbitrary content, such as commas, which is ordinarily a delimiter in the generator expression syntax.
2013-02-26 03:50:49 +04:00
static const struct JoinNode : public cmGeneratorExpressionNode
{
JoinNode() {}
virtual int NumExpectedParameters() const { return 2; }
virtual bool AcceptsArbitraryContentParameter() const { return true; }
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *,
const GeneratorExpressionContent *,
cmGeneratorExpressionDAGChecker *) const
{
std::string result;
std::vector<std::string> list;
cmSystemTools::ExpandListArgument(parameters.front(), list);
std::string sep;
for(std::vector<std::string>::const_iterator li = list.begin();
li != list.end(); ++li)
{
result += sep + *li;
sep = parameters[1];
}
return result;
}
} joinNode;
Use a preprocessor loop to manage the valid transitive properties. Hopefully this will prevent regressions when adding further transitive properties in the future.
2013-06-10 18:01:59 +04:00
#define TRANSITIVE_PROPERTY_NAME(PROPERTY) \
Genex: Simplify the preprocessor looper for interface properties. By removing the INTERFACE_ prefix, we can use this in more contexts.
2013-10-29 12:22:32 +04:00
, "INTERFACE_" #PROPERTY
Use a preprocessor loop to manage the valid transitive properties. Hopefully this will prevent regressions when adding further transitive properties in the future.
2013-06-10 18:01:59 +04:00
Handle INTERFACE properties transitively for includes and defines. Contextually, the behavior is as if the properties content from another target is included in the string and then the result is evaluated.
2012-09-23 15:45:17 +04:00
//----------------------------------------------------------------------------
static const char* targetPropertyTransitiveWhitelist[] = {
Use a preprocessor loop to manage the valid transitive properties. Hopefully this will prevent regressions when adding further transitive properties in the future.
2013-06-10 18:01:59 +04:00
0
CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(TRANSITIVE_PROPERTY_NAME)
Handle INTERFACE properties transitively for includes and defines. Contextually, the behavior is as if the properties content from another target is included in the string and then the result is evaluated.
2012-09-23 15:45:17 +04:00
};
Undefine local preprocessor loop variables. Most occurances of this pattern already contain the undef, so add it to the rest too.
2013-12-31 17:34:16 +04:00
#undef TRANSITIVE_PROPERTY_NAME
Genex: Simplify TARGET_PROPERTY transitive lookup In cmGeneratorExpressionEvaluator, make getLinkedTargetsContent a template so it can traverse over either the Libraries in a cmTarget LinkImplementationLibraries or a cmTarget LinkInterfaceLibraries. This also avoids creating a separate vector<cmTarget*>.
2014-07-15 19:50:32 +04:00
template <typename T>
cmGeneratorExpressionEvaluator: Shorten some long lines Adjust the definitions of getLinkedTargetsContent to avoid long lines.
2014-06-30 18:31:01 +04:00
std::string
getLinkedTargetsContent(
Genex: Simplify TARGET_PROPERTY transitive lookup In cmGeneratorExpressionEvaluator, make getLinkedTargetsContent a template so it can traverse over either the Libraries in a cmTarget LinkImplementationLibraries or a cmTarget LinkInterfaceLibraries. This also avoids creating a separate vector<cmTarget*>.
2014-07-15 19:50:32 +04:00
std::vector<T> const &libraries,
cmGeneratorExpressionEvaluator: Shorten some long lines Adjust the definitions of getLinkedTargetsContent to avoid long lines.
2014-06-30 18:31:01 +04:00
cmTarget const* target,
cmTarget const* headTarget,
cmGeneratorExpressionContext *context,
cmGeneratorExpressionDAGChecker *dagChecker,
const std::string &interfacePropertyName)
GenexEval: Extract a getLinkedTargetsContent from TargetPropertyNode. This will be used to process transitive components of properties which depend on linked targets. Currently only the link interface of the target can be used as the source of the linked targets, but in the next commit it will be possible to use the link implementation as the source of link targets. This commit does not change the semantics of the code.
2013-05-29 02:34:30 +04:00
{
Genex: Simplify TARGET_PROPERTY transitive lookup In cmGeneratorExpressionEvaluator, make getLinkedTargetsContent a template so it can traverse over either the Libraries in a cmTarget LinkImplementationLibraries or a cmTarget LinkInterfaceLibraries. This also avoids creating a separate vector<cmTarget*>.
2014-07-15 19:50:32 +04:00
std::string linkedTargetsContent;
GenexEval: Extract a getLinkedTargetsContent from TargetPropertyNode. This will be used to process transitive components of properties which depend on linked targets. Currently only the link interface of the target can be used as the source of the linked targets, but in the next commit it will be possible to use the link implementation as the source of link targets. This commit does not change the semantics of the code.
2013-05-29 02:34:30 +04:00
std::string sep;
std::string depString;
Genex: Simplify TARGET_PROPERTY transitive lookup In cmGeneratorExpressionEvaluator, make getLinkedTargetsContent a template so it can traverse over either the Libraries in a cmTarget LinkImplementationLibraries or a cmTarget LinkInterfaceLibraries. This also avoids creating a separate vector<cmTarget*>.
2014-07-15 19:50:32 +04:00
for (typename std::vector<T>::const_iterator it = libraries.begin();
it != libraries.end(); ++it)
GenexEval: Extract a getLinkedTargetsContent from TargetPropertyNode. This will be used to process transitive components of properties which depend on linked targets. Currently only the link interface of the target can be used as the source of the linked targets, but in the next commit it will be possible to use the link implementation as the source of link targets. This commit does not change the semantics of the code.
2013-05-29 02:34:30 +04:00
{
Genex: Simplify TARGET_PROPERTY transitive lookup In cmGeneratorExpressionEvaluator, make getLinkedTargetsContent a template so it can traverse over either the Libraries in a cmTarget LinkImplementationLibraries or a cmTarget LinkInterfaceLibraries. This also avoids creating a separate vector<cmTarget*>.
2014-07-15 19:50:32 +04:00
// Broken code can have a target in its own link interface.
// Don't follow such link interface entries so as not to create a
// self-referencing loop.
if (it->Target && it->Target != target)
GenexEval: Extract a getLinkedTargetsContent from TargetPropertyNode. This will be used to process transitive components of properties which depend on linked targets. Currently only the link interface of the target can be used as the source of the linked targets, but in the next commit it will be possible to use the link implementation as the source of link targets. This commit does not change the semantics of the code.
2013-05-29 02:34:30 +04:00
{
Genex: Simplify TARGET_PROPERTY transitive lookup In cmGeneratorExpressionEvaluator, make getLinkedTargetsContent a template so it can traverse over either the Libraries in a cmTarget LinkImplementationLibraries or a cmTarget LinkInterfaceLibraries. This also avoids creating a separate vector<cmTarget*>.
2014-07-15 19:50:32 +04:00
depString +=
sep + "$<TARGET_PROPERTY:" +
it->Target->GetName() + "," + interfacePropertyName + ">";
sep = ";";
GenexEval: Extract a getLinkedTargetsContent from TargetPropertyNode. This will be used to process transitive components of properties which depend on linked targets. Currently only the link interface of the target can be used as the source of the linked targets, but in the next commit it will be possible to use the link implementation as the source of link targets. This commit does not change the semantics of the code.
2013-05-29 02:34:30 +04:00
}
}
Genex: Simplify TARGET_PROPERTY transitive lookup In cmGeneratorExpressionEvaluator, make getLinkedTargetsContent a template so it can traverse over either the Libraries in a cmTarget LinkImplementationLibraries or a cmTarget LinkInterfaceLibraries. This also avoids creating a separate vector<cmTarget*>.
2014-07-15 19:50:32 +04:00
if(!depString.empty())
cmTarget: Change GetTransitivePropertyLinkLibraries to output targets. The callers already skip non-targets, so unify the target search. Change supporting functions to accept a container of targets instead of strings where possible.
2014-02-13 12:53:27 +04:00
{
Genex: Simplify TARGET_PROPERTY transitive lookup In cmGeneratorExpressionEvaluator, make getLinkedTargetsContent a template so it can traverse over either the Libraries in a cmTarget LinkImplementationLibraries or a cmTarget LinkInterfaceLibraries. This also avoids creating a separate vector<cmTarget*>.
2014-07-15 19:50:32 +04:00
cmGeneratorExpression ge(&context->Backtrace);
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(depString);
linkedTargetsContent = cge->Evaluate(target->GetMakefile(),
context->Config,
context->Quiet,
headTarget,
target,
dagChecker);
if (cge->GetHadContextSensitiveCondition())
cmTarget: Change GetTransitivePropertyLinkLibraries to output targets. The callers already skip non-targets, so unify the target search. Change supporting functions to accept a container of targets instead of strings where possible.
2014-02-13 12:53:27 +04:00
{
Genex: Simplify TARGET_PROPERTY transitive lookup In cmGeneratorExpressionEvaluator, make getLinkedTargetsContent a template so it can traverse over either the Libraries in a cmTarget LinkImplementationLibraries or a cmTarget LinkInterfaceLibraries. This also avoids creating a separate vector<cmTarget*>.
2014-07-15 19:50:32 +04:00
context->HadContextSensitiveCondition = true;
cmTarget: Change GetTransitivePropertyLinkLibraries to output targets. The callers already skip non-targets, so unify the target search. Change supporting functions to accept a container of targets instead of strings where possible.
2014-02-13 12:53:27 +04:00
}
Genex: Track whether an expression depends on the 'head' target
2014-07-21 21:02:22 +04:00
if (cge->GetHadHeadSensitiveCondition())
{
context->HadHeadSensitiveCondition = true;
}
cmTarget: Change GetTransitivePropertyLinkLibraries to output targets. The callers already skip non-targets, so unify the target search. Change supporting functions to accept a container of targets instead of strings where possible.
2014-02-13 12:53:27 +04:00
}
Genex: Refactor empty element strip In cmGeneratorExpressionEvaluator, teach getLinkedTargetsContent to call cmGeneratorExpression::StripEmptyListElements to transform its return value so that callers do not have to do so.
2014-07-15 23:22:08 +04:00
linkedTargetsContent =
cmGeneratorExpression::StripEmptyListElements(linkedTargetsContent);
Genex: Simplify TARGET_PROPERTY transitive lookup In cmGeneratorExpressionEvaluator, make getLinkedTargetsContent a template so it can traverse over either the Libraries in a cmTarget LinkImplementationLibraries or a cmTarget LinkInterfaceLibraries. This also avoids creating a separate vector<cmTarget*>.
2014-07-15 19:50:32 +04:00
return linkedTargetsContent;
cmTarget: Change GetTransitivePropertyLinkLibraries to output targets. The callers already skip non-targets, so unify the target search. Change supporting functions to accept a container of targets instead of strings where possible.
2014-02-13 12:53:27 +04:00
}
Add a generator expression for target properties. There are two overloads, so that it can use the operational target when a target property is being evaluated, and a target can alternatively be specified by name. At this point, the generators don't chain. That comes later.
2012-09-12 06:23:31 +04:00
//----------------------------------------------------------------------------
Add API to check that dependent target properties form a DAG. Initially this will only be used to check for self-references, but can be extended to check for cycles when chaining properties of other targets.
2012-09-18 15:42:23 +04:00
static const struct TargetPropertyNode : public cmGeneratorExpressionNode
Add a generator expression for target properties. There are two overloads, so that it can use the operational target when a target property is being evaluated, and a target can alternatively be specified by name. At this point, the generators don't chain. That comes later.
2012-09-12 06:23:31 +04:00
{
TargetPropertyNode() {}
// This node handles errors on parameter count itself.
Add $<LINK_LANGUAGE> generator expression They can't be used when evaluating link libraries, but they can be used for include directories and compile definitions. Later they can be used for compile options.
2013-05-16 17:52:25 +04:00
virtual int NumExpectedParameters() const { return OneOrMoreParameters; }
Add a generator expression for target properties. There are two overloads, so that it can use the operational target when a target property is being evaluated, and a target can alternatively be specified by name. At this point, the generators don't chain. That comes later.
2012-09-12 06:23:31 +04:00
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *context,
Add API to check that dependent target properties form a DAG. Initially this will only be used to check for self-references, but can be extended to check for cycles when chaining properties of other targets.
2012-09-18 15:42:23 +04:00
const GeneratorExpressionContent *content,
Add a self-reference check for target properties. Prevent constructs like: ... INCLUDE_DIRECTORIES "$<TARGET_PROPERTY:INCLUDE_DIRECTORIES>" Indirect self-references (cycles) are also prevented here, but indirect generator expression references of any kind are not possible yet anyway.
2012-09-18 15:53:39 +04:00
cmGeneratorExpressionDAGChecker *dagCheckerParent
) const
Add a generator expression for target properties. There are two overloads, so that it can use the operational target when a target property is being evaluated, and a target can alternatively be specified by name. At this point, the generators don't chain. That comes later.
2012-09-12 06:23:31 +04:00
{
if (parameters.size() != 1 && parameters.size() != 2)
{
reportError(context, content->GetOriginalExpression(),
"$<TARGET_PROPERTY:...> expression requires one or two parameters");
return std::string();
}
regex: Use static regexs where possible Rather than declaring and compiling a constant regex every time a chunk of code is executed, build the regex once.
2014-04-30 21:12:29 +04:00
static cmsys::RegularExpression propertyNameValidator("^[A-Za-z0-9_]+$");
GenEx: Validate target and property names. They must be non-empty, and match a restrictive regexp.
2012-10-04 02:31:24 +04:00
cmTarget: Make GetProperty() const. This has follow-on effects for other methods and classes. Further work on making the use of const cmTarget pointers common can be done, particularly with a view to generate-time methods.
2013-10-30 01:21:20 +04:00
cmTarget const* target = context->HeadTarget;
Add a generator expression for target properties. There are two overloads, so that it can use the operational target when a target property is being evaluated, and a target can alternatively be specified by name. At this point, the generators don't chain. That comes later.
2012-09-12 06:23:31 +04:00
std::string propertyName = *parameters.begin();
Don't crash when a target is expected but is not available.
2013-01-03 23:56:32 +04:00
Genex: Track whether an expression depends on the 'head' target
2014-07-21 21:02:22 +04:00
if (parameters.size() == 1)
{
context->HadHeadSensitiveCondition = true;
}
Don't crash when a target is expected but is not available.
2013-01-03 23:56:32 +04:00
if (!target && parameters.size() == 1)
{
reportError(context, content->GetOriginalExpression(),
Genex: Clarify error message on use with non-binary targets (#14899).
2014-05-29 00:02:57 +04:00
"$<TARGET_PROPERTY:prop> may only be used with binary targets. "
"It may not be used with add_custom_command or add_custom_target. "
"Specify the target to read a property from using the "
"$<TARGET_PROPERTY:tgt,prop> signature instead.");
Don't crash when a target is expected but is not available.
2013-01-03 23:56:32 +04:00
return std::string();
}
Add a generator expression for target properties. There are two overloads, so that it can use the operational target when a target property is being evaluated, and a target can alternatively be specified by name. At this point, the generators don't chain. That comes later.
2012-09-12 06:23:31 +04:00
if (parameters.size() == 2)
{
GenEx: Don't use std::vector::at(int). It might not exist with GCC 2.9.
2012-10-04 13:21:05 +04:00
if (parameters.begin()->empty() && parameters[1].empty())
GenEx: Validate target and property names. They must be non-empty, and match a restrictive regexp.
2012-10-04 02:31:24 +04:00
{
reportError(context, content->GetOriginalExpression(),
"$<TARGET_PROPERTY:tgt,prop> expression requires a non-empty "
"target name and property name.");
return std::string();
}
if (parameters.begin()->empty())
{
reportError(context, content->GetOriginalExpression(),
"$<TARGET_PROPERTY:tgt,prop> expression requires a non-empty "
"target name.");
return std::string();
}
GenEx: Report actual target name not found, not "0" each time.
2012-10-04 02:32:39 +04:00
std::string targetName = parameters.front();
GenEx: Don't use std::vector::at(int). It might not exist with GCC 2.9.
2012-10-04 13:21:05 +04:00
propertyName = parameters[1];
De-duplicate validation of genex target names.
2013-02-06 16:32:15 +04:00
if (!cmGeneratorExpression::IsValidTargetName(targetName))
GenEx: Validate target and property names. They must be non-empty, and match a restrictive regexp.
2012-10-04 02:31:24 +04:00
{
GexEx: Validate Target names and property names differently. In the unit test, use the same IMPORTED_LOCATION trick that the ExportImport test uses.
2012-10-19 15:11:59 +04:00
if (!propertyNameValidator.find(propertyName.c_str()))
GenEx: Validate target and property names. They must be non-empty, and match a restrictive regexp.
2012-10-04 02:31:24 +04:00
{
::reportError(context, content->GetOriginalExpression(),
"Target name and property name not supported.");
return std::string();
}
::reportError(context, content->GetOriginalExpression(),
"Target name not supported.");
return std::string();
}
Add the ALIAS target concept for libraries and executables. * The ALIAS name must match a validity regex. * Executables and libraries may be aliased. * An ALIAS acts immutable. It can not be used as the lhs of target_link_libraries or other commands. * An ALIAS can be used with add_custom_command, add_custom_target, and add_test in the same way regular targets can. * The target of an ALIAS can be retrieved with the ALIASED_TARGET target property. * An ALIAS does not appear in the generated buildsystem. It is kept separate from cmMakefile::Targets for that reason. * A target may have multiple aliases. * An ALIAS target may not itself have an alias. * An IMPORTED target may not have an alias. * An ALIAS may not be exported or imported.
2013-07-12 11:14:31 +04:00
if(propertyName == "ALIASED_TARGET")
{
cmMakefile: make some methods take const std::string& instead of const char* Most callers already have a std::string, on which they called c_str() to pass it into these methods, which internally converted it back to std::string. Pass a std::string directly to these methods now, avoiding all these conversions. Those methods that only pass in a const char* will get the conversion to std::string now only once.
2014-01-16 02:56:38 +04:00
if(context->Makefile->IsAlias(targetName))
Add the ALIAS target concept for libraries and executables. * The ALIAS name must match a validity regex. * Executables and libraries may be aliased. * An ALIAS acts immutable. It can not be used as the lhs of target_link_libraries or other commands. * An ALIAS can be used with add_custom_command, add_custom_target, and add_test in the same way regular targets can. * The target of an ALIAS can be retrieved with the ALIASED_TARGET target property. * An ALIAS does not appear in the generated buildsystem. It is kept separate from cmMakefile::Targets for that reason. * A target may have multiple aliases. * An ALIAS target may not itself have an alias. * An IMPORTED target may not have an alias. * An ALIAS may not be exported or imported.
2013-07-12 11:14:31 +04:00
{
cmMakefile: make some methods take const std::string& instead of const char* Most callers already have a std::string, on which they called c_str() to pass it into these methods, which internally converted it back to std::string. Pass a std::string directly to these methods now, avoiding all these conversions. Those methods that only pass in a const char* will get the conversion to std::string now only once.
2014-01-16 02:56:38 +04:00
if(cmTarget* tgt = context->Makefile->FindTargetToUse(targetName))
Add the ALIAS target concept for libraries and executables. * The ALIAS name must match a validity regex. * Executables and libraries may be aliased. * An ALIAS acts immutable. It can not be used as the lhs of target_link_libraries or other commands. * An ALIAS can be used with add_custom_command, add_custom_target, and add_test in the same way regular targets can. * The target of an ALIAS can be retrieved with the ALIASED_TARGET target property. * An ALIAS does not appear in the generated buildsystem. It is kept separate from cmMakefile::Targets for that reason. * A target may have multiple aliases. * An ALIAS target may not itself have an alias. * An IMPORTED target may not have an alias. * An ALIAS may not be exported or imported.
2013-07-12 11:14:31 +04:00
{
return tgt->GetName();
}
}
return "";
}
cmMakefile: make some methods take const std::string& instead of const char* Most callers already have a std::string, on which they called c_str() to pass it into these methods, which internally converted it back to std::string. Pass a std::string directly to these methods now, avoiding all these conversions. Those methods that only pass in a const char* will get the conversion to std::string now only once.
2014-01-16 02:56:38 +04:00
target = context->Makefile->FindTargetToUse(targetName);
Add a generator expression for target properties. There are two overloads, so that it can use the operational target when a target property is being evaluated, and a target can alternatively be specified by name. At this point, the generators don't chain. That comes later.
2012-09-12 06:23:31 +04:00
if (!target)
{
cmOStringStream e;
e << "Target \""
GenEx: Report actual target name not found, not "0" each time.
2012-10-04 02:32:39 +04:00
<< targetName
Add a generator expression for target properties. There are two overloads, so that it can use the operational target when a target property is being evaluated, and a target can alternatively be specified by name. At this point, the generators don't chain. That comes later.
2012-09-12 06:23:31 +04:00
<< "\" not found.";
reportError(context, content->GetOriginalExpression(), e.str());
GenEx: Return after error reported.
2012-10-04 02:32:22 +04:00
return std::string();
Add a generator expression for target properties. There are two overloads, so that it can use the operational target when a target property is being evaluated, and a target can alternatively be specified by name. At this point, the generators don't chain. That comes later.
2012-09-12 06:23:31 +04:00
}
Keep track of all targets seen while evaluating a genex. As dependencies of the generator expression, these will re-exported in try_compile generated code.
2013-02-09 14:12:20 +04:00
context->AllTargets.insert(target);
GenEx: Validate target and property names. They must be non-empty, and match a restrictive regexp.
2012-10-04 02:31:24 +04:00
}
Keep track of properties used to determine linker libraries. Those properties can't later be implicitly defined by the interface of those link libraries.
2012-11-05 17:48:42 +04:00
if (target == context->HeadTarget)
{
// Keep track of the properties seen while processing.
// The evaluation of the LINK_LIBRARIES generator expressions
Don't keep track of content determined by target property values. This tracking was added during the development of commit 042ecf04 (Add API to calculate link-interface-dependent bool properties or error., 2013-01-06), but was never used. It was not necessary to use the content because what is really useful in that logic is to determine if a property has been implied to be null by appearing in a LINK_LIBRARIES genex. I think the motivating usecase for developing the feature of keeping track of the targets relevant to a property was that I thought it would make it possible to allow requiring granular compatibility of interface properties only for targets which depended on the interface property. Eg: add_library(foo ...) add_library(bar ...) add_executable(user ...) # Read the INTERFACE_POSITION_INDEPENDENT_CODE from bar, but not # from foo: target_link_libraries(user foo $<$<TARGET_PROPERTY:POSTITION_INDEPENDENT_CODE>:bar>) This obviously doesn't make sense. We require that INTERFACE properties are consistent across all linked targets instead.
2013-02-07 16:04:46 +04:00
// will check this to ensure that properties have one consistent
// value for all evaluations.
Keep track of properties used to determine linker libraries. Those properties can't later be implicitly defined by the interface of those link libraries.
2012-11-05 17:48:42 +04:00
context->SeenTargetProperties.insert(propertyName);
}
GenEx: Validate target and property names. They must be non-empty, and match a restrictive regexp.
2012-10-04 02:31:24 +04:00
if (propertyName.empty())
{
reportError(context, content->GetOriginalExpression(),
"$<TARGET_PROPERTY:...> expression requires a non-empty property "
"name.");
return std::string();
}
regex: Search on strings where possible
2014-04-30 21:13:21 +04:00
if (!propertyNameValidator.find(propertyName))
GenEx: Validate target and property names. They must be non-empty, and match a restrictive regexp.
2012-10-04 02:31:24 +04:00
{
::reportError(context, content->GetOriginalExpression(),
"Property name not supported.");
return std::string();
Add a generator expression for target properties. There are two overloads, so that it can use the operational target when a target property is being evaluated, and a target can alternatively be specified by name. At this point, the generators don't chain. That comes later.
2012-09-12 06:23:31 +04:00
}
Add a self-reference check for target properties. Prevent constructs like: ... INCLUDE_DIRECTORIES "$<TARGET_PROPERTY:INCLUDE_DIRECTORIES>" Indirect self-references (cycles) are also prevented here, but indirect generator expression references of any kind are not possible yet anyway.
2012-09-18 15:53:39 +04:00
Don't crash when a target is expected but is not available.
2013-01-03 23:56:32 +04:00
assert(target);
Remove the LINK_LANGUAGE generator expression. It accepted an optional argument to test for equality, but no way to get the linker language of a particular target. TARGET_PROPERTY provides this flexibility and STREQUAL provides the necessary API for equality test. Extend the CompileDefinitions test to cover accessing the property of another target.
2013-07-18 14:58:48 +04:00
if (propertyName == "LINKER_LANGUAGE")
{
Genex: Disallow LINKER_LANGUAGE only when used on a static library. For shared libraries and executables, the linker_language is indepenedent of the linked libraries.
2013-07-25 11:12:28 +04:00
if (target->LinkLanguagePropagatesToDependents() &&
cmTarget: Allow transitive evaluation of SOURCES property. Extend the cmGeneratorExpressionDAGChecker with an interface returning the name of the top target. Use that to determine when there is a DAG violation, as required by the RunCMake.Languages tests.
2014-02-13 23:52:21 +04:00
dagCheckerParent && (dagCheckerParent->EvaluatingLinkLibraries()
|| dagCheckerParent->EvaluatingSources()))
Remove the LINK_LANGUAGE generator expression. It accepted an optional argument to test for equality, but no way to get the linker language of a particular target. TARGET_PROPERTY provides this flexibility and STREQUAL provides the necessary API for equality test. Extend the CompileDefinitions test to cover accessing the property of another target.
2013-07-18 14:58:48 +04:00
{
reportError(context, content->GetOriginalExpression(),
"LINKER_LANGUAGE target property can not be used while evaluating "
Genex: Disallow LINKER_LANGUAGE only when used on a static library. For shared libraries and executables, the linker_language is indepenedent of the linked libraries.
2013-07-25 11:12:28 +04:00
"link libraries for a static library");
Remove the LINK_LANGUAGE generator expression. It accepted an optional argument to test for equality, but no way to get the linker language of a particular target. TARGET_PROPERTY provides this flexibility and STREQUAL provides the necessary API for equality test. Extend the CompileDefinitions test to cover accessing the property of another target.
2013-07-18 14:58:48 +04:00
return std::string();
}
stringapi: Use strings for the languages
2014-02-04 06:20:56 +04:00
return target->GetLinkerLanguage(context->Config);
Remove the LINK_LANGUAGE generator expression. It accepted an optional argument to test for equality, but no way to get the linker language of a particular target. TARGET_PROPERTY provides this flexibility and STREQUAL provides the necessary API for equality test. Extend the CompileDefinitions test to cover accessing the property of another target.
2013-07-18 14:58:48 +04:00
}
Add a self-reference check for target properties. Prevent constructs like: ... INCLUDE_DIRECTORIES "$<TARGET_PROPERTY:INCLUDE_DIRECTORIES>" Indirect self-references (cycles) are also prevented here, but indirect generator expression references of any kind are not possible yet anyway.
2012-09-18 15:53:39 +04:00
cmGeneratorExpressionDAGChecker dagChecker(context->Backtrace,
target->GetName(),
propertyName,
content,
dagCheckerParent);
Genex: Fix case of methods in the dag checker.
2014-01-05 08:25:09 +04:00
switch (dagChecker.Check())
Add a self-reference check for target properties. Prevent constructs like: ... INCLUDE_DIRECTORIES "$<TARGET_PROPERTY:INCLUDE_DIRECTORIES>" Indirect self-references (cycles) are also prevented here, but indirect generator expression references of any kind are not possible yet anyway.
2012-09-18 15:53:39 +04:00
{
Make cycles in target properties ignored, not an error. Constructs such as these are an error as they are direct self-references: set_property(TARGET foo APPEND PROPERTY INCLUDE_DIRECTORIES $<TARGET_PROPERTY:foo,INCLUDE_DIRECTORIES>) set_property(TARGET foo APPEND PROPERTY INCLUDE_DIRECTORIES $<TARGET_PROPERTY:INCLUDE_DIRECTORIES>) However, this is an indirect self-reference in a cycle, and not an error: set_property(TARGET foo APPEND PROPERTY INCLUDE_DIRECTORIES $<TARGET_PROPERTY:bar,INCLUDE_DIRECTORIES>) set_property(TARGET bar APPEND PROPERTY INCLUDE_DIRECTORIES $<TARGET_PROPERTY:foo,INCLUDE_DIRECTORIES>)
2012-12-21 18:49:19 +04:00
case cmGeneratorExpressionDAGChecker::SELF_REFERENCE:
Genex: Fix case of methods in the dag checker.
2014-01-05 08:25:09 +04:00
dagChecker.ReportError(context, content->GetOriginalExpression());
Add a self-reference check for target properties. Prevent constructs like: ... INCLUDE_DIRECTORIES "$<TARGET_PROPERTY:INCLUDE_DIRECTORIES>" Indirect self-references (cycles) are also prevented here, but indirect generator expression references of any kind are not possible yet anyway.
2012-09-18 15:53:39 +04:00
return std::string();
Make cycles in target properties ignored, not an error. Constructs such as these are an error as they are direct self-references: set_property(TARGET foo APPEND PROPERTY INCLUDE_DIRECTORIES $<TARGET_PROPERTY:foo,INCLUDE_DIRECTORIES>) set_property(TARGET foo APPEND PROPERTY INCLUDE_DIRECTORIES $<TARGET_PROPERTY:INCLUDE_DIRECTORIES>) However, this is an indirect self-reference in a cycle, and not an error: set_property(TARGET foo APPEND PROPERTY INCLUDE_DIRECTORIES $<TARGET_PROPERTY:bar,INCLUDE_DIRECTORIES>) set_property(TARGET bar APPEND PROPERTY INCLUDE_DIRECTORIES $<TARGET_PROPERTY:foo,INCLUDE_DIRECTORIES>)
2012-12-21 18:49:19 +04:00
case cmGeneratorExpressionDAGChecker::CYCLIC_REFERENCE:
// No error. We just skip cyclic references.
return std::string();
Optimize genex evaluation for includes and defines. While porting boost to use these features, the generation step took too long (several minutes before I stopped it). The reason was that the boost libraries form a large interdependent mesh. The libraries list their dependencies in their INTERFACE such as: $<LINKED:boost::core>;$<LINKED:boost::config>;$<LINKED:boost::mpl> As boost::core already depends on the boost::config libraries, that expression has no impact on the end-content, as it is removed after the generation step. There is no DAG issue though, so the generator expression evaluation would fully evaluate them. In the case of the config library, it also depends on the core library, so all depends are followed through that again, despite the fact that they've just been evaluated. After this patch, the evaluation skips libraries if they have already been seen via depends or directly in the content. This patch keeps track of targets whose INTERFACE has been consumed already. The INCLUDE_DIRECTORIES and COMPILE_DEFINITIONS properties are whitelisted because repeated content will be stripped out later during generation. For other properties now and in the future, that may not be the case.
2013-02-01 12:38:40 +04:00
case cmGeneratorExpressionDAGChecker::ALREADY_SEEN:
Use a preprocessor loop to manage the valid transitive properties. Hopefully this will prevent regressions when adding further transitive properties in the future.
2013-06-10 18:01:59 +04:00
for (size_t i = 1;
Genex: Remove use of TransitiveWhitelistCompare Replace with generic solution based on cmArray* for better readability.
2013-10-22 03:12:24 +04:00
i < cmArraySize(targetPropertyTransitiveWhitelist);
Only use early evaluation termination for transitive properties. We need to make sure expressions which evaluate TARGET_PROPERTY:TYPE multiple times for example get the correct result each time, and not an empty string instead.
2013-02-07 15:33:20 +04:00
++i)
{
if (targetPropertyTransitiveWhitelist[i] == propertyName)
{
// No error. We're not going to find anything new here.
return std::string();
}
}
Make cycles in target properties ignored, not an error. Constructs such as these are an error as they are direct self-references: set_property(TARGET foo APPEND PROPERTY INCLUDE_DIRECTORIES $<TARGET_PROPERTY:foo,INCLUDE_DIRECTORIES>) set_property(TARGET foo APPEND PROPERTY INCLUDE_DIRECTORIES $<TARGET_PROPERTY:INCLUDE_DIRECTORIES>) However, this is an indirect self-reference in a cycle, and not an error: set_property(TARGET foo APPEND PROPERTY INCLUDE_DIRECTORIES $<TARGET_PROPERTY:bar,INCLUDE_DIRECTORIES>) set_property(TARGET bar APPEND PROPERTY INCLUDE_DIRECTORIES $<TARGET_PROPERTY:foo,INCLUDE_DIRECTORIES>)
2012-12-21 18:49:19 +04:00
case cmGeneratorExpressionDAGChecker::DAG:
break;
Add a self-reference check for target properties. Prevent constructs like: ... INCLUDE_DIRECTORIES "$<TARGET_PROPERTY:INCLUDE_DIRECTORIES>" Indirect self-references (cycles) are also prevented here, but indirect generator expression references of any kind are not possible yet anyway.
2012-09-18 15:53:39 +04:00
}
Remove some c_str() calls. Use the clang RemoveCStrCalls tool to automatically migrate the code. This was only run on linux, so does not have any positive or negative effect on other platforms.
2014-03-11 03:04:11 +04:00
const char *prop = target->GetProperty(propertyName);
Use the link information as a source of compile definitions and includes. After evaluating the INTERFACE_INCLUDE_DIRECTORIES, of a target in a generator expression, also read the INTERFACE_INCLUDE_DIRECTORIES of its link interface dependencies. That means that code such as this will result in the 'user' target using /bar/include and /foo/include: add_library(foo ...) target_include_directories(foo INTERFACE /foo/include) add_library(bar ...) target_include_directories(bar INTERFACE /bar/include) target_link_libraries(bar LINK_PUBLIC foo) add_executable(user ...) target_include_directories(user PRIVATE $<TARGET_PROPERTY:bar,INTERFACE_INCLUDE_DIRECTORIES>) Also process the interface include directories from direct link dependencies for in-build targets. The situation is similar for the INTERFACE_COMPILE_DEFINITIONS. The include directories related code is currently more complex because we also need to store a backtrace at configure-time for the purpose of debugging includes. The compile definitions related code will use the same pattern in the future. This is not a change in behavior, as existing code has the same effect, but that existing code will be removed in follow-up commits.
2013-02-12 14:29:09 +04:00
if (dagCheckerParent)
Handle INTERFACE properties transitively for includes and defines. Contextually, the behavior is as if the properties content from another target is included in the string and then the result is evaluated.
2012-09-23 15:45:17 +04:00
{
Use the link information as a source of compile definitions and includes. After evaluating the INTERFACE_INCLUDE_DIRECTORIES, of a target in a generator expression, also read the INTERFACE_INCLUDE_DIRECTORIES of its link interface dependencies. That means that code such as this will result in the 'user' target using /bar/include and /foo/include: add_library(foo ...) target_include_directories(foo INTERFACE /foo/include) add_library(bar ...) target_include_directories(bar INTERFACE /bar/include) target_link_libraries(bar LINK_PUBLIC foo) add_executable(user ...) target_include_directories(user PRIVATE $<TARGET_PROPERTY:bar,INTERFACE_INCLUDE_DIRECTORIES>) Also process the interface include directories from direct link dependencies for in-build targets. The situation is similar for the INTERFACE_COMPILE_DEFINITIONS. The include directories related code is currently more complex because we also need to store a backtrace at configure-time for the purpose of debugging includes. The compile definitions related code will use the same pattern in the future. This is not a change in behavior, as existing code has the same effect, but that existing code will be removed in follow-up commits.
2013-02-12 14:29:09 +04:00
if (dagCheckerParent->EvaluatingLinkLibraries())
Make INTERFACE determined properties readable in generator expressions. The properties are evaluated as link-dependent interface properties when evaluating the generator expressions.
2013-01-19 14:21:14 +04:00
{
Genex: Fix stack overflow in transitive property evaluation. Commit v2.8.11~156^2~2 (Expand includes and defines transitively in 'external' genexes., 2013-02-13) introduced a recursive loop and a stack overflow during evaluation of a link implementation which depends on a transitive property, such as add_library(empty1 ...) add_library(empty2 ...) target_link_libraries(empty1 PRIVATE $<$<STREQUAL:$<TARGET_PROPERTY:INCLUDE_DIRECTORIES>,/foo/bar>:empty2> ) There is no use-case for code like that currently, but it should not cause a stack overflow. Avoid the recursion by reporting an error early if a case like this is found.
2014-05-11 18:04:53 +04:00
#define TRANSITIVE_PROPERTY_COMPARE(PROPERTY) \
(#PROPERTY == propertyName || "INTERFACE_" #PROPERTY == propertyName) ||
if (CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(TRANSITIVE_PROPERTY_COMPARE)
false)
{
reportError(context, content->GetOriginalExpression(),
"$<TARGET_PROPERTY:...> expression in link libraries "
"evaluation depends on target property which is transitive "
"over the link libraries, creating a recursion.");
return std::string();
}
#undef TRANSITIVE_PROPERTY_COMPARE
Use the link information as a source of compile definitions and includes. After evaluating the INTERFACE_INCLUDE_DIRECTORIES, of a target in a generator expression, also read the INTERFACE_INCLUDE_DIRECTORIES of its link interface dependencies. That means that code such as this will result in the 'user' target using /bar/include and /foo/include: add_library(foo ...) target_include_directories(foo INTERFACE /foo/include) add_library(bar ...) target_include_directories(bar INTERFACE /bar/include) target_link_libraries(bar LINK_PUBLIC foo) add_executable(user ...) target_include_directories(user PRIVATE $<TARGET_PROPERTY:bar,INTERFACE_INCLUDE_DIRECTORIES>) Also process the interface include directories from direct link dependencies for in-build targets. The situation is similar for the INTERFACE_COMPILE_DEFINITIONS. The include directories related code is currently more complex because we also need to store a backtrace at configure-time for the purpose of debugging includes. The compile definitions related code will use the same pattern in the future. This is not a change in behavior, as existing code has the same effect, but that existing code will be removed in follow-up commits.
2013-02-12 14:29:09 +04:00
if(!prop)
{
return std::string();
}
Make INTERFACE determined properties readable in generator expressions. The properties are evaluated as link-dependent interface properties when evaluating the generator expressions.
2013-01-19 14:21:14 +04:00
}
Use the link information as a source of compile definitions and includes. After evaluating the INTERFACE_INCLUDE_DIRECTORIES, of a target in a generator expression, also read the INTERFACE_INCLUDE_DIRECTORIES of its link interface dependencies. That means that code such as this will result in the 'user' target using /bar/include and /foo/include: add_library(foo ...) target_include_directories(foo INTERFACE /foo/include) add_library(bar ...) target_include_directories(bar INTERFACE /bar/include) target_link_libraries(bar LINK_PUBLIC foo) add_executable(user ...) target_include_directories(user PRIVATE $<TARGET_PROPERTY:bar,INTERFACE_INCLUDE_DIRECTORIES>) Also process the interface include directories from direct link dependencies for in-build targets. The situation is similar for the INTERFACE_COMPILE_DEFINITIONS. The include directories related code is currently more complex because we also need to store a backtrace at configure-time for the purpose of debugging includes. The compile definitions related code will use the same pattern in the future. This is not a change in behavior, as existing code has the same effect, but that existing code will be removed in follow-up commits.
2013-02-12 14:29:09 +04:00
else
Make INTERFACE determined properties readable in generator expressions. The properties are evaluated as link-dependent interface properties when evaluating the generator expressions.
2013-01-19 14:21:14 +04:00
{
Use a preprocessor loop to manage the valid transitive properties. Hopefully this will prevent regressions when adding further transitive properties in the future.
2013-06-10 18:01:59 +04:00
#define ASSERT_TRANSITIVE_PROPERTY_METHOD(METHOD) \
dagCheckerParent->METHOD () ||
assert(
CM_FOR_EACH_TRANSITIVE_PROPERTY_METHOD(
ASSERT_TRANSITIVE_PROPERTY_METHOD)
false);
Undefine local preprocessor loop variables. Most occurances of this pattern already contain the undef, so add it to the rest too.
2013-12-31 17:34:16 +04:00
#undef ASSERT_TRANSITIVE_PROPERTY_METHOD
Genex: Adjust code layout slightly
2014-07-15 23:19:44 +04:00
}
Expand includes and defines transitively in 'external' genexes. This means that we can use expressions of the form $<TARGET_PROPERTY:foo,INTERFACE_INCLUDE_DIRECTORIES> to get a list of the interface include directories of foo, including those coming from dependencies. We can't have a test of a target which has a single include directory in its INCLUDE_DIRECTORIES because the shell on the MSYS platforms transforms a single include directory to include a prefix, which is not what the test expects. We test a target with two directories instead as a means to test a target with no link dependencies.
2013-02-13 15:35:31 +04:00
}
std::string linkedTargetsContent;
std::string interfacePropertyName;
Genex: Avoid repeated search of transitive property whitelist In cmGeneratorExpressionEvaluator, avoid searching through the list of transitive interface property names repeatedly during evaluation of TargetPropertyNode. Simply record the results of the first search for later re-use.
2014-07-15 23:18:05 +04:00
bool isInterfaceProperty = false;
Use the link information as a source of compile definitions and includes. After evaluating the INTERFACE_INCLUDE_DIRECTORIES, of a target in a generator expression, also read the INTERFACE_INCLUDE_DIRECTORIES of its link interface dependencies. That means that code such as this will result in the 'user' target using /bar/include and /foo/include: add_library(foo ...) target_include_directories(foo INTERFACE /foo/include) add_library(bar ...) target_include_directories(bar INTERFACE /bar/include) target_link_libraries(bar LINK_PUBLIC foo) add_executable(user ...) target_include_directories(user PRIVATE $<TARGET_PROPERTY:bar,INTERFACE_INCLUDE_DIRECTORIES>) Also process the interface include directories from direct link dependencies for in-build targets. The situation is similar for the INTERFACE_COMPILE_DEFINITIONS. The include directories related code is currently more complex because we also need to store a backtrace at configure-time for the purpose of debugging includes. The compile definitions related code will use the same pattern in the future. This is not a change in behavior, as existing code has the same effect, but that existing code will be removed in follow-up commits.
2013-02-12 14:29:09 +04:00
Genex: Use a preprocessor foreach to follow transitive properties.
2013-10-25 17:55:40 +04:00
#define POPULATE_INTERFACE_PROPERTY_NAME(prop) \
Genex: Avoid repeated search of transitive property whitelist In cmGeneratorExpressionEvaluator, avoid searching through the list of transitive interface property names repeatedly during evaluation of TargetPropertyNode. Simply record the results of the first search for later re-use.
2014-07-15 23:18:05 +04:00
if (propertyName == #prop) \
Genex: Use a preprocessor foreach to follow transitive properties.
2013-10-25 17:55:40 +04:00
{ \
interfacePropertyName = "INTERFACE_" #prop; \
} \
Genex: Avoid repeated search of transitive property whitelist In cmGeneratorExpressionEvaluator, avoid searching through the list of transitive interface property names repeatedly during evaluation of TargetPropertyNode. Simply record the results of the first search for later re-use.
2014-07-15 23:18:05 +04:00
else if (propertyName == "INTERFACE_" #prop) \
{ \
interfacePropertyName = "INTERFACE_" #prop; \
isInterfaceProperty = true; \
} \
Genex: Use a preprocessor foreach to follow transitive properties.
2013-10-25 17:55:40 +04:00
else
CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(POPULATE_INTERFACE_PROPERTY_NAME)
// Note that the above macro terminates with an else
Use new cmHasLiteralPrefix function
2013-11-20 05:12:00 +04:00
/* else */ if (cmHasLiteralPrefix(propertyName.c_str(),
"COMPILE_DEFINITIONS_"))
Expand includes and defines transitively in 'external' genexes. This means that we can use expressions of the form $<TARGET_PROPERTY:foo,INTERFACE_INCLUDE_DIRECTORIES> to get a list of the interface include directories of foo, including those coming from dependencies. We can't have a test of a target which has a single include directory in its INCLUDE_DIRECTORIES because the shell on the MSYS platforms transforms a single include directory to include a prefix, which is not what the test expects. We test a target with two directories instead as a means to test a target with no link dependencies.
2013-02-13 15:35:31 +04:00
{
cmTarget: Deprecate COMPILE_DEFINITIONS_ properties with a policy.
2013-12-30 16:33:02 +04:00
cmPolicies::PolicyStatus polSt =
context->Makefile->GetPolicyStatus(cmPolicies::CMP0043);
if (polSt == cmPolicies::WARN || polSt == cmPolicies::OLD)
{
interfacePropertyName = "INTERFACE_COMPILE_DEFINITIONS";
}
Expand includes and defines transitively in 'external' genexes. This means that we can use expressions of the form $<TARGET_PROPERTY:foo,INTERFACE_INCLUDE_DIRECTORIES> to get a list of the interface include directories of foo, including those coming from dependencies. We can't have a test of a target which has a single include directory in its INCLUDE_DIRECTORIES because the shell on the MSYS platforms transforms a single include directory to include a prefix, which is not what the test expects. We test a target with two directories instead as a means to test a target with no link dependencies.
2013-02-13 15:35:31 +04:00
}
Genex: Use a preprocessor foreach to follow transitive properties.
2013-10-25 17:55:40 +04:00
#undef POPULATE_INTERFACE_PROPERTY_NAME
cmTarget: Make GetProperty() const. This has follow-on effects for other methods and classes. Further work on making the use of const cmTarget pointers common can be done, particularly with a view to generate-time methods.
2013-10-30 01:21:20 +04:00
cmTarget const* headTarget = context->HeadTarget
? context->HeadTarget : target;
Genex: Fix the HEAD target used for evaluated expressions If the expression $<TARGET_PROPERTY:prop> appears in the content of a target property, the target that prop is read from is the 'head target' of the expression. In contexts such as evaluating the content of a target property during generation, such as INCLUDE_DIRECTORIES, the 'head target' is the one on which the initial request was made. If evaluating a generator expression which is not a target property content, the target must be explicitly specified. Such contexts include add_custom_command and file(GENERATE). The content might then look like $<TARGET_PROPERTY:tgt,prop> However, as there is no HeadTarget set, any generator expressions evaluated as part of reading prop from tgt which do not specify the tgt directly report an error. Modify the logic of the TARGET_PROPERTY generator expression so that in such contexts, the 'head target' is set to the appropriate target which was first encountered.
2013-06-04 01:53:29 +04:00
Genex: Avoid repeated search of transitive property whitelist In cmGeneratorExpressionEvaluator, avoid searching through the list of transitive interface property names repeatedly during evaluation of TargetPropertyNode. Simply record the results of the first search for later re-use.
2014-07-15 23:18:05 +04:00
if(isInterfaceProperty)
Expand includes and defines transitively in 'external' genexes. This means that we can use expressions of the form $<TARGET_PROPERTY:foo,INTERFACE_INCLUDE_DIRECTORIES> to get a list of the interface include directories of foo, including those coming from dependencies. We can't have a test of a target which has a single include directory in its INCLUDE_DIRECTORIES because the shell on the MSYS platforms transforms a single include directory to include a prefix, which is not what the test expects. We test a target with two directories instead as a means to test a target with no link dependencies.
2013-02-13 15:35:31 +04:00
{
cmTarget: Drop GetTransitivePropertyTargets method Inline the implementation at the only remaining call site.
2014-07-15 19:42:43 +04:00
if(cmTarget::LinkInterfaceLibraries const* iface =
target->GetLinkInterfaceLibraries(context->Config, headTarget, true))
{
GenexEval: Extract a getLinkedTargetsContent from TargetPropertyNode. This will be used to process transitive components of properties which depend on linked targets. Currently only the link interface of the target can be used as the source of the linked targets, but in the next commit it will be possible to use the link implementation as the source of link targets. This commit does not change the semantics of the code.
2013-05-29 02:34:30 +04:00
linkedTargetsContent =
Genex: Simplify TARGET_PROPERTY transitive lookup In cmGeneratorExpressionEvaluator, make getLinkedTargetsContent a template so it can traverse over either the Libraries in a cmTarget LinkImplementationLibraries or a cmTarget LinkInterfaceLibraries. This also avoids creating a separate vector<cmTarget*>.
2014-07-15 19:50:32 +04:00
getLinkedTargetsContent(iface->Libraries, target,
headTarget,
context, &dagChecker,
interfacePropertyName);
Use the link information as a source of compile definitions and includes. After evaluating the INTERFACE_INCLUDE_DIRECTORIES, of a target in a generator expression, also read the INTERFACE_INCLUDE_DIRECTORIES of its link interface dependencies. That means that code such as this will result in the 'user' target using /bar/include and /foo/include: add_library(foo ...) target_include_directories(foo INTERFACE /foo/include) add_library(bar ...) target_include_directories(bar INTERFACE /bar/include) target_link_libraries(bar LINK_PUBLIC foo) add_executable(user ...) target_include_directories(user PRIVATE $<TARGET_PROPERTY:bar,INTERFACE_INCLUDE_DIRECTORIES>) Also process the interface include directories from direct link dependencies for in-build targets. The situation is similar for the INTERFACE_COMPILE_DEFINITIONS. The include directories related code is currently more complex because we also need to store a backtrace at configure-time for the purpose of debugging includes. The compile definitions related code will use the same pattern in the future. This is not a change in behavior, as existing code has the same effect, but that existing code will be removed in follow-up commits.
2013-02-12 14:29:09 +04:00
}
}
Genex: Avoid repeated search of transitive property whitelist In cmGeneratorExpressionEvaluator, avoid searching through the list of transitive interface property names repeatedly during evaluation of TargetPropertyNode. Simply record the results of the first search for later re-use.
2014-07-15 23:18:05 +04:00
else if(!interfacePropertyName.empty())
GenexEval: Fix evaluation of INCLUDE_DIRECTORIES target property. This property should come from the content of the property itself, plus the INTERFACE_INCLUDE_DIRECTORIES of the link *implementation*. In contrast, when the INTERFACE_INCLUDE_DIRECTORIES is evaluated for a target, the INTERFACE_INCLUDE_DIRECTORIES of the link *interface* is used. Similar logic applies for the COMPILE_DEFINITIONS target properties. If the propertyName is already an INTERFACE_ variant of the property, ie, the expression is similar to $<TARGET_PROPERTY:foo,INTERFACE_INCLUDE_DIRECTORIES> then the INTERFACE_INCLUDE_DIRECTORIES of the link *interface* of foo is used. However, if the propertyName is not an INTERFACE_ variant, and the interfacePropertyName is, ie, the expression is similar to: $<TARGET_PROPERTY:foo,INCLUDE_DIRECTORIES> then the INTERFACE_INCLUDE_DIRECTORIES of the link *implementation* of foo is used.
2013-05-30 17:30:24 +04:00
{
Genex: Adjust code layout slightly
2014-07-15 23:19:44 +04:00
if(cmTarget::LinkImplementationLibraries const* impl =
target->GetLinkImplementationLibraries(context->Config))
GenexEval: Fix evaluation of INCLUDE_DIRECTORIES target property. This property should come from the content of the property itself, plus the INTERFACE_INCLUDE_DIRECTORIES of the link *implementation*. In contrast, when the INTERFACE_INCLUDE_DIRECTORIES is evaluated for a target, the INTERFACE_INCLUDE_DIRECTORIES of the link *interface* is used. Similar logic applies for the COMPILE_DEFINITIONS target properties. If the propertyName is already an INTERFACE_ variant of the property, ie, the expression is similar to $<TARGET_PROPERTY:foo,INTERFACE_INCLUDE_DIRECTORIES> then the INTERFACE_INCLUDE_DIRECTORIES of the link *interface* of foo is used. However, if the propertyName is not an INTERFACE_ variant, and the interfacePropertyName is, ie, the expression is similar to: $<TARGET_PROPERTY:foo,INCLUDE_DIRECTORIES> then the INTERFACE_INCLUDE_DIRECTORIES of the link *implementation* of foo is used.
2013-05-30 17:30:24 +04:00
{
linkedTargetsContent =
Genex: Avoid repeated search of transitive property whitelist In cmGeneratorExpressionEvaluator, avoid searching through the list of transitive interface property names repeatedly during evaluation of TargetPropertyNode. Simply record the results of the first search for later re-use.
2014-07-15 23:18:05 +04:00
getLinkedTargetsContent(impl->Libraries, target,
headTarget,
context, &dagChecker,
interfacePropertyName);
Use the link information as a source of compile definitions and includes. After evaluating the INTERFACE_INCLUDE_DIRECTORIES, of a target in a generator expression, also read the INTERFACE_INCLUDE_DIRECTORIES of its link interface dependencies. That means that code such as this will result in the 'user' target using /bar/include and /foo/include: add_library(foo ...) target_include_directories(foo INTERFACE /foo/include) add_library(bar ...) target_include_directories(bar INTERFACE /bar/include) target_link_libraries(bar LINK_PUBLIC foo) add_executable(user ...) target_include_directories(user PRIVATE $<TARGET_PROPERTY:bar,INTERFACE_INCLUDE_DIRECTORIES>) Also process the interface include directories from direct link dependencies for in-build targets. The situation is similar for the INTERFACE_COMPILE_DEFINITIONS. The include directories related code is currently more complex because we also need to store a backtrace at configure-time for the purpose of debugging includes. The compile definitions related code will use the same pattern in the future. This is not a change in behavior, as existing code has the same effect, but that existing code will be removed in follow-up commits.
2013-02-12 14:29:09 +04:00
}
}
if (!prop)
{
INTERFACE_LIBRARY: Avoid codepaths which set unneeded properties. As an INTERFACE_LIBRARY has no direct link dependencies, we can short-circuit in cmGeneratorExpressionEvaluator and in cmGlobalGenerator::CheckLocalGenerators. As they do not generate any output directly, any generate- or install- related code acn also be short-circuited. Many of the local generators already do this. Because only INTERFACE related properties make sense on INTERFACE_LIBRARY targets, avoid setting other properties, for example via defaults.
2013-11-20 15:44:04 +04:00
if (target->IsImported()
|| target->GetType() == cmTarget::INTERFACE_LIBRARY)
Use the link information as a source of compile definitions and includes. After evaluating the INTERFACE_INCLUDE_DIRECTORIES, of a target in a generator expression, also read the INTERFACE_INCLUDE_DIRECTORIES of its link interface dependencies. That means that code such as this will result in the 'user' target using /bar/include and /foo/include: add_library(foo ...) target_include_directories(foo INTERFACE /foo/include) add_library(bar ...) target_include_directories(bar INTERFACE /bar/include) target_link_libraries(bar LINK_PUBLIC foo) add_executable(user ...) target_include_directories(user PRIVATE $<TARGET_PROPERTY:bar,INTERFACE_INCLUDE_DIRECTORIES>) Also process the interface include directories from direct link dependencies for in-build targets. The situation is similar for the INTERFACE_COMPILE_DEFINITIONS. The include directories related code is currently more complex because we also need to store a backtrace at configure-time for the purpose of debugging includes. The compile definitions related code will use the same pattern in the future. This is not a change in behavior, as existing code has the same effect, but that existing code will be removed in follow-up commits.
2013-02-12 14:29:09 +04:00
{
return linkedTargetsContent;
Make INTERFACE determined properties readable in generator expressions. The properties are evaluated as link-dependent interface properties when evaluating the generator expressions.
2013-01-19 14:21:14 +04:00
}
if (target->IsLinkInterfaceDependentBoolProperty(propertyName,
context->Config))
{
Cache context-independent includes on evaluation. Generator expressions whose output depends on the configuration now record that fact. The GetIncludeDirectories method can use that result to cache the include directories for later calls. GetIncludeDirectories is called multiple times for a target for each configuration, so this should restore performance for multi-config generators.
2013-02-03 10:33:15 +04:00
context->HadContextSensitiveCondition = true;
Make INTERFACE determined properties readable in generator expressions. The properties are evaluated as link-dependent interface properties when evaluating the generator expressions.
2013-01-19 14:21:14 +04:00
return target->GetLinkInterfaceDependentBoolProperty(
propertyName,
context->Config) ? "1" : "0";
}
Add the COMPATIBLE_INTERFACE_STRING property.
2013-01-06 16:49:20 +04:00
if (target->IsLinkInterfaceDependentStringProperty(propertyName,
context->Config))
{
Cache context-independent includes on evaluation. Generator expressions whose output depends on the configuration now record that fact. The GetIncludeDirectories method can use that result to cache the include directories for later calls. GetIncludeDirectories is called multiple times for a target for each configuration, so this should restore performance for multi-config generators.
2013-02-03 10:33:15 +04:00
context->HadContextSensitiveCondition = true;
Handle reading empty properties defined by the link interface. This was segfaulting before.
2013-01-31 14:18:49 +04:00
const char *propContent =
target->GetLinkInterfaceDependentStringProperty(
Add the COMPATIBLE_INTERFACE_STRING property.
2013-01-06 16:49:20 +04:00
propertyName,
context->Config);
Handle reading empty properties defined by the link interface. This was segfaulting before.
2013-01-31 14:18:49 +04:00
return propContent ? propContent : "";
Add the COMPATIBLE_INTERFACE_STRING property.
2013-01-06 16:49:20 +04:00
}
cmTarget: Add interface for compatible numeric properties When using the boost MPL library, one can set a define to increase the limit of how many variadic elements should be supported. The default for BOOST_MPL_LIMIT_VECTOR_SIZE is 20: http://www.boost.org/doc/libs/1_36_0/libs/mpl/doc/refmanual/limit-vector-size.html If the foo library requires that to be set to 30, and the independent bar library requires it to be set to 40, consumers of both need to set it to 40. add_library(foo INTERFACE) set_property(TARGET foo PROPERTY INTERFACE_boost_mpl_vector_size 30) set_property(TARGET foo PROPERTY COMPATIBLE_INTERFACE_NUMBER_MAX boost_mpl_vector_size) target_compile_definitions(foo INTERFACE BOOST_MPL_LIMIT_VECTOR_SIZE=$<TARGET_PROPERTY:boost_mpl_vector_size>) add_library(bar INTERFACE) set_property(TARGET bar PROPERTY INTERFACE_boost_mpl_vector_size 40) # Technically the next two lines are redundant, but as foo and bar are # independent, they both set these interfaces. set_property(TARGET bar PROPERTY COMPATIBLE_INTERFACE_NUMBER_MAX boost_mpl_vector_size) target_compile_definitions(bar INTERFACE BOOST_MPL_LIMIT_VECTOR_SIZE=$<TARGET_PROPERTY:boost_mpl_vector_size>) add_executable(user) target_link_libraries(user foo bar) Because the TARGET_PROPERTY reads the boost_mpl_vector_size property from the HEAD of the dependency graph (the user target), and because that property appears in the COMPATIBLE_INTERFACE_NUMBER_MAX of the dependencies of the user target, the maximum value for it is chosen for the compile definition, ie, 40. There are also use-cases for choosing the minimum value of a number. In Qt, deprecated API can be disabled by version. Setting the definition QT_DISABLE_DEPRECATED_BEFORE=0 disables no deprecated API. Setting it to 0x501000 disables API which was deprecated before Qt 5.1 etc. If two dependencies require the use of API which was deprecated in different Qt versions, then COMPATIBLE_INTERFACE_NUMBER_MIN can be used to ensure that both can compile.
2013-10-22 21:51:36 +04:00
if (target->IsLinkInterfaceDependentNumberMinProperty(propertyName,
context->Config))
{
context->HadContextSensitiveCondition = true;
const char *propContent =
target->GetLinkInterfaceDependentNumberMinProperty(
propertyName,
context->Config);
return propContent ? propContent : "";
}
if (target->IsLinkInterfaceDependentNumberMaxProperty(propertyName,
context->Config))
{
context->HadContextSensitiveCondition = true;
const char *propContent =
target->GetLinkInterfaceDependentNumberMaxProperty(
propertyName,
context->Config);
return propContent ? propContent : "";
}
Make INTERFACE determined properties readable in generator expressions. The properties are evaluated as link-dependent interface properties when evaluating the generator expressions.
2013-01-19 14:21:14 +04:00
Use the link information as a source of compile definitions and includes. After evaluating the INTERFACE_INCLUDE_DIRECTORIES, of a target in a generator expression, also read the INTERFACE_INCLUDE_DIRECTORIES of its link interface dependencies. That means that code such as this will result in the 'user' target using /bar/include and /foo/include: add_library(foo ...) target_include_directories(foo INTERFACE /foo/include) add_library(bar ...) target_include_directories(bar INTERFACE /bar/include) target_link_libraries(bar LINK_PUBLIC foo) add_executable(user ...) target_include_directories(user PRIVATE $<TARGET_PROPERTY:bar,INTERFACE_INCLUDE_DIRECTORIES>) Also process the interface include directories from direct link dependencies for in-build targets. The situation is similar for the INTERFACE_COMPILE_DEFINITIONS. The include directories related code is currently more complex because we also need to store a backtrace at configure-time for the purpose of debugging includes. The compile definitions related code will use the same pattern in the future. This is not a change in behavior, as existing code has the same effect, but that existing code will be removed in follow-up commits.
2013-02-12 14:29:09 +04:00
return linkedTargetsContent;
Handle INTERFACE properties transitively for includes and defines. Contextually, the behavior is as if the properties content from another target is included in the string and then the result is evaluated.
2012-09-23 15:45:17 +04:00
}
cmTarget: Add interface for compatible numeric properties When using the boost MPL library, one can set a define to increase the limit of how many variadic elements should be supported. The default for BOOST_MPL_LIMIT_VECTOR_SIZE is 20: http://www.boost.org/doc/libs/1_36_0/libs/mpl/doc/refmanual/limit-vector-size.html If the foo library requires that to be set to 30, and the independent bar library requires it to be set to 40, consumers of both need to set it to 40. add_library(foo INTERFACE) set_property(TARGET foo PROPERTY INTERFACE_boost_mpl_vector_size 30) set_property(TARGET foo PROPERTY COMPATIBLE_INTERFACE_NUMBER_MAX boost_mpl_vector_size) target_compile_definitions(foo INTERFACE BOOST_MPL_LIMIT_VECTOR_SIZE=$<TARGET_PROPERTY:boost_mpl_vector_size>) add_library(bar INTERFACE) set_property(TARGET bar PROPERTY INTERFACE_boost_mpl_vector_size 40) # Technically the next two lines are redundant, but as foo and bar are # independent, they both set these interfaces. set_property(TARGET bar PROPERTY COMPATIBLE_INTERFACE_NUMBER_MAX boost_mpl_vector_size) target_compile_definitions(bar INTERFACE BOOST_MPL_LIMIT_VECTOR_SIZE=$<TARGET_PROPERTY:boost_mpl_vector_size>) add_executable(user) target_link_libraries(user foo bar) Because the TARGET_PROPERTY reads the boost_mpl_vector_size property from the HEAD of the dependency graph (the user target), and because that property appears in the COMPATIBLE_INTERFACE_NUMBER_MAX of the dependencies of the user target, the maximum value for it is chosen for the compile definition, ie, 40. There are also use-cases for choosing the minimum value of a number. In Qt, deprecated API can be disabled by version. Setting the definition QT_DISABLE_DEPRECATED_BEFORE=0 disables no deprecated API. Setting it to 0x501000 disables API which was deprecated before Qt 5.1 etc. If two dependencies require the use of API which was deprecated in different Qt versions, then COMPATIBLE_INTERFACE_NUMBER_MIN can be used to ensure that both can compile.
2013-10-22 21:51:36 +04:00
if (!target->IsImported()
&& dagCheckerParent && !dagCheckerParent->EvaluatingLinkLibraries())
{
if (target->IsLinkInterfaceDependentNumberMinProperty(propertyName,
context->Config))
{
context->HadContextSensitiveCondition = true;
const char *propContent =
target->GetLinkInterfaceDependentNumberMinProperty(
propertyName,
context->Config);
return propContent ? propContent : "";
}
if (target->IsLinkInterfaceDependentNumberMaxProperty(propertyName,
context->Config))
{
context->HadContextSensitiveCondition = true;
const char *propContent =
target->GetLinkInterfaceDependentNumberMaxProperty(
propertyName,
context->Config);
return propContent ? propContent : "";
}
}
Genex: Avoid repeated search of transitive property whitelist In cmGeneratorExpressionEvaluator, avoid searching through the list of transitive interface property names repeatedly during evaluation of TargetPropertyNode. Simply record the results of the first search for later re-use.
2014-07-15 23:18:05 +04:00
if(!interfacePropertyName.empty())
Handle INTERFACE properties transitively for includes and defines. Contextually, the behavior is as if the properties content from another target is included in the string and then the result is evaluated.
2012-09-23 15:45:17 +04:00
{
Genex: Avoid repeated search of transitive property whitelist In cmGeneratorExpressionEvaluator, avoid searching through the list of transitive interface property names repeatedly during evaluation of TargetPropertyNode. Simply record the results of the first search for later re-use.
2014-07-15 23:18:05 +04:00
cmGeneratorExpression ge(&context->Backtrace);
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(prop);
cge->SetEvaluateForBuildsystem(context->EvaluateForBuildsystem);
std::string result = cge->Evaluate(context->Makefile,
Handle INTERFACE properties transitively for includes and defines. Contextually, the behavior is as if the properties content from another target is included in the string and then the result is evaluated.
2012-09-23 15:45:17 +04:00
context->Config,
context->Quiet,
Genex: Fix the HEAD target used for evaluated expressions If the expression $<TARGET_PROPERTY:prop> appears in the content of a target property, the target that prop is read from is the 'head target' of the expression. In contexts such as evaluating the content of a target property during generation, such as INCLUDE_DIRECTORIES, the 'head target' is the one on which the initial request was made. If evaluating a generator expression which is not a target property content, the target must be explicitly specified. Such contexts include add_custom_command and file(GENERATE). The content might then look like $<TARGET_PROPERTY:tgt,prop> However, as there is no HeadTarget set, any generator expressions evaluated as part of reading prop from tgt which do not specify the tgt directly report an error. Modify the logic of the TARGET_PROPERTY generator expression so that in such contexts, the 'head target' is set to the appropriate target which was first encountered.
2013-06-04 01:53:29 +04:00
headTarget,
Handle INTERFACE properties transitively for includes and defines. Contextually, the behavior is as if the properties content from another target is included in the string and then the result is evaluated.
2012-09-23 15:45:17 +04:00
target,
&dagChecker);
Cache context-independent includes on evaluation. Generator expressions whose output depends on the configuration now record that fact. The GetIncludeDirectories method can use that result to cache the include directories for later calls. GetIncludeDirectories is called multiple times for a target for each configuration, so this should restore performance for multi-config generators.
2013-02-03 10:33:15 +04:00
Genex: Avoid repeated search of transitive property whitelist In cmGeneratorExpressionEvaluator, avoid searching through the list of transitive interface property names repeatedly during evaluation of TargetPropertyNode. Simply record the results of the first search for later re-use.
2014-07-15 23:18:05 +04:00
if (cge->GetHadContextSensitiveCondition())
{
context->HadContextSensitiveCondition = true;
}
Genex: Track whether an expression depends on the 'head' target
2014-07-21 21:02:22 +04:00
if (cge->GetHadHeadSensitiveCondition())
{
context->HadHeadSensitiveCondition = true;
}
Genex: Avoid repeated search of transitive property whitelist In cmGeneratorExpressionEvaluator, avoid searching through the list of transitive interface property names repeatedly during evaluation of TargetPropertyNode. Simply record the results of the first search for later re-use.
2014-07-15 23:18:05 +04:00
if (!linkedTargetsContent.empty())
{
result += (result.empty() ? "" : ";") + linkedTargetsContent;
Handle INTERFACE properties transitively for includes and defines. Contextually, the behavior is as if the properties content from another target is included in the string and then the result is evaluated.
2012-09-23 15:45:17 +04:00
}
Genex: Avoid repeated search of transitive property whitelist In cmGeneratorExpressionEvaluator, avoid searching through the list of transitive interface property names repeatedly during evaluation of TargetPropertyNode. Simply record the results of the first search for later re-use.
2014-07-15 23:18:05 +04:00
return result;
Handle INTERFACE properties transitively for includes and defines. Contextually, the behavior is as if the properties content from another target is included in the string and then the result is evaluated.
2012-09-23 15:45:17 +04:00
}
return prop;
Add a generator expression for target properties. There are two overloads, so that it can use the operational target when a target property is being evaluated, and a target can alternatively be specified by name. At this point, the generators don't chain. That comes later.
2012-09-12 06:23:31 +04:00
}
} targetPropertyNode;
Add the TARGET_NAME generator expression. It will be used as a preprocessing marker.
2012-12-10 14:33:23 +04:00
//----------------------------------------------------------------------------
static const struct TargetNameNode : public cmGeneratorExpressionNode
{
TargetNameNode() {}
virtual bool GeneratesContent() const { return true; }
Rename the method determining if a genex accepts arbitrary content. The meaning of this will be expanded to generator expressions with more than a single parameter.
2013-04-25 15:28:57 +04:00
virtual bool AcceptsArbitraryContentParameter() const { return true; }
Add the TARGET_NAME generator expression. It will be used as a preprocessing marker.
2012-12-10 14:33:23 +04:00
virtual bool RequiresLiteralInput() const { return true; }
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *,
const GeneratorExpressionContent *,
cmGeneratorExpressionDAGChecker *) const
{
return parameters.front();
}
virtual int NumExpectedParameters() const { return 1; }
} targetNameNode;
Genex: Evaluate TARGET_OBJECTS as a normal expression.
2014-02-26 18:59:18 +04:00
//----------------------------------------------------------------------------
static const struct TargetObjectsNode : public cmGeneratorExpressionNode
{
TargetObjectsNode() {}
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *context,
const GeneratorExpressionContent *content,
cmGeneratorExpressionDAGChecker *) const
{
Genex: Only evaluate TARGET_OBJECTS to determine target sources. The output of this expression may contain macros for IDEs to replace such as $(Configuration), $(CURRENT_ARCH) etc. To avoid generating content which is not usable in other contexts, report an error if there is an attempt to use it in other contexts. This commit may be reverted in the future if a solution to the above difference is implemented.
2014-03-20 18:37:12 +04:00
if (!context->EvaluateForBuildsystem)
{
cmOStringStream e;
e << "The evaluation of the TARGET_OBJECTS generator expression "
"is only suitable for consumption by CMake. It is not suitable "
"for writing out elsewhere.";
reportError(context, content->GetOriginalExpression(), e.str());
return std::string();
}
Genex: Evaluate TARGET_OBJECTS as a normal expression.
2014-02-26 18:59:18 +04:00
std::string tgtName = parameters.front();
cmGeneratorTarget* gt =
context->Makefile->FindGeneratorTargetToUse(tgtName.c_str());
if (!gt)
{
cmOStringStream e;
e << "Objects of target \"" << tgtName
<< "\" referenced but no such target exists.";
reportError(context, content->GetOriginalExpression(), e.str());
return std::string();
}
if (gt->GetType() != cmTarget::OBJECT_LIBRARY)
{
cmOStringStream e;
e << "Objects of target \"" << tgtName
<< "\" referenced but is not an OBJECT library.";
reportError(context, content->GetOriginalExpression(), e.str());
return std::string();
}
std::vector<cmSourceFile const*> objectSources;
cmTarget: Make the source files depend on the config. Disallow the use of config-specific source files with the Visual Studio and Xcode generators. They don't have any way to represent the condition currently. Use the same common-config API in cmQtAutoGenerators. While it accepts config-specific files, it doesn't have to support multiple configurations yet. Loop over the configs in cmTargetTraceDependencies and cmGlobalGenerator::WriteSummary and consume all source files. Loop over the configs in cmComputeTargetDepends and compute the object library dependencies for each config.
2014-02-13 20:25:00 +04:00
gt->GetObjectSources(objectSources, context->Config);
Genex: Evaluate TARGET_OBJECTS as a normal expression.
2014-02-26 18:59:18 +04:00
std::map<cmSourceFile const*, std::string> mapping;
for(std::vector<cmSourceFile const*>::const_iterator it
= objectSources.begin(); it != objectSources.end(); ++it)
{
mapping[*it];
}
gt->LocalGenerator->ComputeObjectFilenames(mapping, gt);
std::string obj_dir = gt->ObjectDirectory;
std::string result;
const char* sep = "";
for(std::map<cmSourceFile const*, std::string>::const_iterator it
= mapping.begin(); it != mapping.end(); ++it)
{
assert(!it->second.empty());
result += sep;
std::string objFile = obj_dir + it->second;
cmSourceFile* sf = context->Makefile->GetOrCreateSource(objFile, true);
sf->SetObjectLibrary(tgtName);
sf->SetProperty("EXTERNAL_OBJECT", "1");
result += objFile;
sep = ";";
}
return result;
}
} targetObjectsNode;
Features: Add COMPILE_FEATURES generator expression. Allow setting build properties based on the features available for a target. The availability of features is determined at generate-time by evaluating the link implementation. Ensure that the <LANG>_STANDARD determined while evaluating COMPILE_FEATURES in the link implementation is not lower than that provided by the INTERFACE of the link implementation. This is similar to handling of transitive properties such as POSITION_INDEPENDENT_CODE.
2014-05-15 13:32:30 +04:00
//----------------------------------------------------------------------------
static const struct CompileFeaturesNode : public cmGeneratorExpressionNode
{
CompileFeaturesNode() {}
virtual int NumExpectedParameters() const { return OneOrMoreParameters; }
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *context,
const GeneratorExpressionContent *content,
cmGeneratorExpressionDAGChecker *dagChecker) const
{
cmTarget const* target = context->HeadTarget;
if (!target)
{
reportError(context, content->GetOriginalExpression(),
"$<COMPILE_FEATURE> may only be used with binary targets. It may "
"not be used with add_custom_command or add_custom_target.");
return std::string();
}
Genex: Track whether an expression depends on the 'head' target
2014-07-21 21:02:22 +04:00
context->HadHeadSensitiveCondition = true;
Features: Add COMPILE_FEATURES generator expression. Allow setting build properties based on the features available for a target. The availability of features is determined at generate-time by evaluating the link implementation. Ensure that the <LANG>_STANDARD determined while evaluating COMPILE_FEATURES in the link implementation is not lower than that provided by the INTERFACE of the link implementation. This is similar to handling of transitive properties such as POSITION_INDEPENDENT_CODE.
2014-05-15 13:32:30 +04:00
typedef std::map<std::string, std::vector<std::string> > LangMap;
static LangMap availableFeatures;
LangMap testedFeatures;
for (std::vector<std::string>::const_iterator it = parameters.begin();
it != parameters.end(); ++it)
{
std::string error;
std::string lang;
if (!context->Makefile->CompileFeatureKnown(context->HeadTarget,
*it, lang, &error))
{
reportError(context, content->GetOriginalExpression(), error);
return std::string();
}
testedFeatures[lang].push_back(*it);
if (availableFeatures.find(lang) == availableFeatures.end())
{
const char* featuresKnown
= context->Makefile->CompileFeaturesAvailable(lang, &error);
if (!featuresKnown)
{
reportError(context, content->GetOriginalExpression(), error);
return std::string();
}
cmSystemTools::ExpandListArgument(featuresKnown,
availableFeatures[lang]);
}
}
bool evalLL = dagChecker && dagChecker->EvaluatingLinkLibraries();
std::string result;
for (LangMap::const_iterator lit = testedFeatures.begin();
lit != testedFeatures.end(); ++lit)
{
for (std::vector<std::string>::const_iterator it = lit->second.begin();
it != lit->second.end(); ++it)
{
if (!context->Makefile->HaveFeatureAvailable(target,
lit->first, *it))
{
if (evalLL)
{
const char* l = target->GetProperty(lit->first + "_STANDARD");
if (!l)
{
l = context->Makefile
->GetDefinition("CMAKE_" + lit->first + "_STANDARD_DEFAULT");
}
assert(l);
context->MaxLanguageStandard[target][lit->first] = l;
}
else
{
return "0";
}
}
}
}
return "1";
}
} compileFeaturesNode;
Add the $<TARGET_POLICY> expression This new expression allows checking how a policy was set when a target was created. That information is only recorded for a subset of policies, so a whitelist is used.
2013-01-16 19:42:39 +04:00
//----------------------------------------------------------------------------
static const char* targetPolicyWhitelist[] = {
Genex: Make CMP0021 and CMP0022 usable with TARGET_POLICY Use preprocessor loops and add a unit test for the appropriate policies. All policies whose value is recorded at target creation time should be part of this list.
2013-06-28 13:25:40 +04:00
0
#define TARGET_POLICY_STRING(POLICY) \
, #POLICY
CM_FOR_EACH_TARGET_POLICY(TARGET_POLICY_STRING)
#undef TARGET_POLICY_STRING
Add the $<TARGET_POLICY> expression This new expression allows checking how a policy was set when a target was created. That information is only recorded for a subset of policies, so a whitelist is used.
2013-01-16 19:42:39 +04:00
};
cmTarget: Make GetProperty() const. This has follow-on effects for other methods and classes. Further work on making the use of const cmTarget pointers common can be done, particularly with a view to generate-time methods.
2013-10-30 01:21:20 +04:00
cmPolicies::PolicyStatus statusForTarget(cmTarget const* tgt,
const char *policy)
Add the $<TARGET_POLICY> expression This new expression allows checking how a policy was set when a target was created. That information is only recorded for a subset of policies, so a whitelist is used.
2013-01-16 19:42:39 +04:00
{
#define RETURN_POLICY(POLICY) \
if (strcmp(policy, #POLICY) == 0) \
{ \
return tgt->GetPolicyStatus ## POLICY (); \
} \
Genex: Make CMP0021 and CMP0022 usable with TARGET_POLICY Use preprocessor loops and add a unit test for the appropriate policies. All policies whose value is recorded at target creation time should be part of this list.
2013-06-28 13:25:40 +04:00
CM_FOR_EACH_TARGET_POLICY(RETURN_POLICY)
Add the $<TARGET_POLICY> expression This new expression allows checking how a policy was set when a target was created. That information is only recorded for a subset of policies, so a whitelist is used.
2013-01-16 19:42:39 +04:00
#undef RETURN_POLICY
assert("!Unreachable code. Not a valid policy");
return cmPolicies::WARN;
}
cmPolicies::PolicyID policyForString(const char *policy_id)
{
#define RETURN_POLICY_ID(POLICY_ID) \
if (strcmp(policy_id, #POLICY_ID) == 0) \
{ \
return cmPolicies:: POLICY_ID; \
} \
Genex: Make CMP0021 and CMP0022 usable with TARGET_POLICY Use preprocessor loops and add a unit test for the appropriate policies. All policies whose value is recorded at target creation time should be part of this list.
2013-06-28 13:25:40 +04:00
CM_FOR_EACH_TARGET_POLICY(RETURN_POLICY_ID)
Add the $<TARGET_POLICY> expression This new expression allows checking how a policy was set when a target was created. That information is only recorded for a subset of policies, so a whitelist is used.
2013-01-16 19:42:39 +04:00
#undef RETURN_POLICY_ID
assert("!Unreachable code. Not a valid policy");
return cmPolicies::CMP0002;
}
//----------------------------------------------------------------------------
static const struct TargetPolicyNode : public cmGeneratorExpressionNode
{
TargetPolicyNode() {}
virtual int NumExpectedParameters() const { return 1; }
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *context ,
const GeneratorExpressionContent *content,
cmGeneratorExpressionDAGChecker *) const
{
if (!context->HeadTarget)
{
reportError(context, content->GetOriginalExpression(),
Genex: Clarify error message on use with non-binary targets (#14899).
2014-05-29 00:02:57 +04:00
"$<TARGET_POLICY:prop> may only be used with binary targets. It "
"may not be used with add_custom_command or add_custom_target.");
Add the $<TARGET_POLICY> expression This new expression allows checking how a policy was set when a target was created. That information is only recorded for a subset of policies, so a whitelist is used.
2013-01-16 19:42:39 +04:00
return std::string();
}
Cache context-independent includes on evaluation. Generator expressions whose output depends on the configuration now record that fact. The GetIncludeDirectories method can use that result to cache the include directories for later calls. GetIncludeDirectories is called multiple times for a target for each configuration, so this should restore performance for multi-config generators.
2013-02-03 10:33:15 +04:00
context->HadContextSensitiveCondition = true;
Genex: Track whether an expression depends on the 'head' target
2014-07-21 21:02:22 +04:00
context->HadHeadSensitiveCondition = true;
Cache context-independent includes on evaluation. Generator expressions whose output depends on the configuration now record that fact. The GetIncludeDirectories method can use that result to cache the include directories for later calls. GetIncludeDirectories is called multiple times for a target for each configuration, so this should restore performance for multi-config generators.
2013-02-03 10:33:15 +04:00
Genex: Use cmArraySize for targetPolicyWhitelist For better readability.
2013-10-22 03:14:03 +04:00
for (size_t i = 1; i < cmArraySize(targetPolicyWhitelist); ++i)
Add the $<TARGET_POLICY> expression This new expression allows checking how a policy was set when a target was created. That information is only recorded for a subset of policies, so a whitelist is used.
2013-01-16 19:42:39 +04:00
{
const char *policy = targetPolicyWhitelist[i];
if (parameters.front() == policy)
{
cmMakefile *mf = context->HeadTarget->GetMakefile();
switch(statusForTarget(context->HeadTarget, policy))
{
case cmPolicies::WARN:
mf->IssueMessage(cmake::AUTHOR_WARNING,
mf->GetPolicies()->
GetPolicyWarning(policyForString(policy)));
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
case cmPolicies::OLD:
return "0";
case cmPolicies::NEW:
return "1";
}
}
}
reportError(context, content->GetOriginalExpression(),
"$<TARGET_POLICY:prop> may only be used with a limited number of "
Genex: Make CMP0021 and CMP0022 usable with TARGET_POLICY Use preprocessor loops and add a unit test for the appropriate policies. All policies whose value is recorded at target creation time should be part of this list.
2013-06-28 13:25:40 +04:00
"policies. Currently it may be used with the following policies:\n"
#define STRINGIFY_HELPER(X) #X
#define STRINGIFY(X) STRINGIFY_HELPER(X)
#define TARGET_POLICY_LIST_ITEM(POLICY) \
" * " STRINGIFY(POLICY) "\n"
CM_FOR_EACH_TARGET_POLICY(TARGET_POLICY_LIST_ITEM)
#undef TARGET_POLICY_LIST_ITEM
Add the $<TARGET_POLICY> expression This new expression allows checking how a policy was set when a target was created. That information is only recorded for a subset of policies, so a whitelist is used.
2013-01-16 19:42:39 +04:00
);
return std::string();
}
} targetPolicyNode;
Add the INSTALL_PREFIX genex.
2013-01-27 12:43:44 +04:00
//----------------------------------------------------------------------------
static const struct InstallPrefixNode : public cmGeneratorExpressionNode
{
InstallPrefixNode() {}
Make it an error for INSTALL_PREFIX to be evaluated. An empty string is not likely going to produce expected results in any evaluation context. It is replaced by preprocessing currently.
2013-01-30 20:49:47 +04:00
virtual bool GeneratesContent() const { return true; }
Add the INSTALL_PREFIX genex.
2013-01-27 12:43:44 +04:00
virtual int NumExpectedParameters() const { return 0; }
std::string Evaluate(const std::vector<std::string> &,
Make it an error for INSTALL_PREFIX to be evaluated. An empty string is not likely going to produce expected results in any evaluation context. It is replaced by preprocessing currently.
2013-01-30 20:49:47 +04:00
cmGeneratorExpressionContext *context,
const GeneratorExpressionContent *content,
Add the INSTALL_PREFIX genex.
2013-01-27 12:43:44 +04:00
cmGeneratorExpressionDAGChecker *) const
{
Make it an error for INSTALL_PREFIX to be evaluated. An empty string is not likely going to produce expected results in any evaluation context. It is replaced by preprocessing currently.
2013-01-30 20:49:47 +04:00
reportError(context, content->GetOriginalExpression(),
"INSTALL_PREFIX is a marker for install(EXPORT) only. It "
"should never be evaluated.");
Add the INSTALL_PREFIX genex.
2013-01-27 12:43:44 +04:00
return std::string();
}
} installPrefixNode;
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
//----------------------------------------------------------------------------
template<bool linker, bool soname>
struct TargetFilesystemArtifactResultCreator
{
static std::string Create(cmTarget* target,
cmGeneratorExpressionContext *context,
const GeneratorExpressionContent *content);
};
//----------------------------------------------------------------------------
template<>
struct TargetFilesystemArtifactResultCreator<false, true>
{
static std::string Create(cmTarget* target,
cmGeneratorExpressionContext *context,
const GeneratorExpressionContent *content)
{
// The target soname file (.so.1).
if(target->IsDLLPlatform())
{
::reportError(context, content->GetOriginalExpression(),
"TARGET_SONAME_FILE is not allowed "
"for DLL target platforms.");
return std::string();
}
if(target->GetType() != cmTarget::SHARED_LIBRARY)
{
::reportError(context, content->GetOriginalExpression(),
"TARGET_SONAME_FILE is allowed only for "
"SHARED libraries.");
return std::string();
}
std::string result = target->GetDirectory(context->Config);
result += "/";
result += target->GetSOName(context->Config);
return result;
}
};
//----------------------------------------------------------------------------
template<>
struct TargetFilesystemArtifactResultCreator<true, false>
{
static std::string Create(cmTarget* target,
cmGeneratorExpressionContext *context,
const GeneratorExpressionContent *content)
{
// The file used to link to the target (.so, .lib, .a).
if(!target->IsLinkable())
{
::reportError(context, content->GetOriginalExpression(),
"TARGET_LINKER_FILE is allowed only for libraries and "
"executables with ENABLE_EXPORTS.");
return std::string();
}
return target->GetFullPath(context->Config,
target->HasImportLibrary());
}
};
//----------------------------------------------------------------------------
template<>
struct TargetFilesystemArtifactResultCreator<false, false>
{
static std::string Create(cmTarget* target,
cmGeneratorExpressionContext *context,
const GeneratorExpressionContent *)
{
return target->GetFullPath(context->Config, false, true);
}
};
//----------------------------------------------------------------------------
template<bool dirQual, bool nameQual>
struct TargetFilesystemArtifactResultGetter
{
static std::string Get(const std::string &result);
};
//----------------------------------------------------------------------------
template<>
struct TargetFilesystemArtifactResultGetter<false, true>
{
static std::string Get(const std::string &result)
{ return cmSystemTools::GetFilenameName(result); }
};
//----------------------------------------------------------------------------
template<>
struct TargetFilesystemArtifactResultGetter<true, false>
{
static std::string Get(const std::string &result)
{ return cmSystemTools::GetFilenamePath(result); }
};
//----------------------------------------------------------------------------
template<>
struct TargetFilesystemArtifactResultGetter<false, false>
{
static std::string Get(const std::string &result)
{ return result; }
};
//----------------------------------------------------------------------------
template<bool linker, bool soname, bool dirQual, bool nameQual>
struct TargetFilesystemArtifact : public cmGeneratorExpressionNode
{
TargetFilesystemArtifact() {}
virtual int NumExpectedParameters() const { return 1; }
std::string Evaluate(const std::vector<std::string> &parameters,
cmGeneratorExpressionContext *context,
Add API to check that dependent target properties form a DAG. Initially this will only be used to check for self-references, but can be extended to check for cycles when chaining properties of other targets.
2012-09-18 15:42:23 +04:00
const GeneratorExpressionContent *content,
Genex: Report error if a target file is needed to evaluate link libraries. Constructs such as target_link_libraries(foo $<$<STREQUAL:$<TARGET_FILE:foo>,foo.so>:bar>) segfault before this patch.
2013-06-14 18:25:29 +04:00
cmGeneratorExpressionDAGChecker *dagChecker) const
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
{
// Lookup the referenced target.
std::string name = *parameters.begin();
De-duplicate validation of genex target names.
2013-02-06 16:32:15 +04:00
if (!cmGeneratorExpression::IsValidTargetName(name))
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
{
::reportError(context, content->GetOriginalExpression(),
"Expression syntax not recognized.");
return std::string();
}
cmMakefile: make some methods take const std::string& instead of const char* Most callers already have a std::string, on which they called c_str() to pass it into these methods, which internally converted it back to std::string. Pass a std::string directly to these methods now, avoiding all these conversions. Those methods that only pass in a const char* will get the conversion to std::string now only once.
2014-01-16 02:56:38 +04:00
cmTarget* target = context->Makefile->FindTargetToUse(name);
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
if(!target)
{
::reportError(context, content->GetOriginalExpression(),
"No target \"" + name + "\"");
return std::string();
}
Genex: Reject $<TARGET_FILE:...> for object libraries (#14532) Teach the cmGeneratorExpressionEvaluator filesystem artifact logic to reject OBJECT_LIBRARY targets since they have no main artifact. Without the explicit rejection evaluation falls through to an internal CMake error message in cmTarget::GetOutputInfo. Extend the RunCMake.GeneratorExpression test to cover these cases.
2013-11-01 18:14:47 +04:00
if(target->GetType() >= cmTarget::OBJECT_LIBRARY &&
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
target->GetType() != cmTarget::UNKNOWN_LIBRARY)
{
::reportError(context, content->GetOriginalExpression(),
"Target \"" + name + "\" is not an executable or library.");
return std::string();
}
cmTarget: Allow transitive evaluation of SOURCES property. Extend the cmGeneratorExpressionDAGChecker with an interface returning the name of the top target. Use that to determine when there is a DAG violation, as required by the RunCMake.Languages tests.
2014-02-13 23:52:21 +04:00
if (dagChecker && (dagChecker->EvaluatingLinkLibraries(name.c_str())
|| (dagChecker->EvaluatingSources()
&& name == dagChecker->TopTarget())))
Genex: Report error if a target file is needed to evaluate link libraries. Constructs such as target_link_libraries(foo $<$<STREQUAL:$<TARGET_FILE:foo>,foo.so>:bar>) segfault before this patch.
2013-06-14 18:25:29 +04:00
{
::reportError(context, content->GetOriginalExpression(),
"Expressions which require the linker language may not "
"be used while evaluating link libraries");
return std::string();
}
Keep track of all targets seen while evaluating a genex. As dependencies of the generator expression, these will re-exported in try_compile generated code.
2013-02-09 14:12:20 +04:00
context->DependTargets.insert(target);
context->AllTargets.insert(target);
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
std::string result =
TargetFilesystemArtifactResultCreator<linker, soname>::Create(
target,
context,
content);
if (context->HadError)
{
return std::string();
}
return
TargetFilesystemArtifactResultGetter<dirQual, nameQual>::Get(result);
}
};
//----------------------------------------------------------------------------
static const
TargetFilesystemArtifact<false, false, false, false> targetFileNode;
static const
TargetFilesystemArtifact<true, false, false, false> targetLinkerFileNode;
static const
TargetFilesystemArtifact<false, true, false, false> targetSoNameFileNode;
static const
TargetFilesystemArtifact<false, false, false, true> targetFileNameNode;
static const
TargetFilesystemArtifact<true, false, false, true> targetLinkerFileNameNode;
static const
TargetFilesystemArtifact<false, true, false, true> targetSoNameFileNameNode;
static const
TargetFilesystemArtifact<false, false, true, false> targetFileDirNode;
static const
TargetFilesystemArtifact<true, false, true, false> targetLinkerFileDirNode;
static const
TargetFilesystemArtifact<false, true, true, false> targetSoNameFileDirNode;
//----------------------------------------------------------------------------
static const
cmGeneratorExpressionNode* GetNode(const std::string &identifier)
{
genex: Store predicates as a map for faster searching May warrant a fast path for predicates which more frequently.
2014-02-06 22:59:50 +04:00
typedef std::map<std::string, const cmGeneratorExpressionNode*> NodeMap;
static NodeMap nodeMap;
if (nodeMap.empty())
{
nodeMap["0"] = &zeroNode;
nodeMap["1"] = &oneNode;
nodeMap["AND"] = &andNode;
nodeMap["OR"] = &orNode;
nodeMap["NOT"] = &notNode;
nodeMap["C_COMPILER_ID"] = &cCompilerIdNode;
nodeMap["CXX_COMPILER_ID"] = &cxxCompilerIdNode;
nodeMap["VERSION_GREATER"] = &versionGreaterNode;
nodeMap["VERSION_LESS"] = &versionLessNode;
nodeMap["VERSION_EQUAL"] = &versionEqualNode;
nodeMap["C_COMPILER_VERSION"] = &cCompilerVersionNode;
nodeMap["CXX_COMPILER_VERSION"] = &cxxCompilerVersionNode;
nodeMap["PLATFORM_ID"] = &platformIdNode;
Features: Add COMPILE_FEATURES generator expression. Allow setting build properties based on the features available for a target. The availability of features is determined at generate-time by evaluating the link implementation. Ensure that the <LANG>_STANDARD determined while evaluating COMPILE_FEATURES in the link implementation is not lower than that provided by the INTERFACE of the link implementation. This is similar to handling of transitive properties such as POSITION_INDEPENDENT_CODE.
2014-05-15 13:32:30 +04:00
nodeMap["COMPILE_FEATURES"] = &compileFeaturesNode;
genex: Store predicates as a map for faster searching May warrant a fast path for predicates which more frequently.
2014-02-06 22:59:50 +04:00
nodeMap["CONFIGURATION"] = &configurationNode;
nodeMap["CONFIG"] = &configurationTestNode;
nodeMap["TARGET_FILE"] = &targetFileNode;
nodeMap["TARGET_LINKER_FILE"] = &targetLinkerFileNode;
nodeMap["TARGET_SONAME_FILE"] = &targetSoNameFileNode;
nodeMap["TARGET_FILE_NAME"] = &targetFileNameNode;
nodeMap["TARGET_LINKER_FILE_NAME"] = &targetLinkerFileNameNode;
nodeMap["TARGET_SONAME_FILE_NAME"] = &targetSoNameFileNameNode;
nodeMap["TARGET_FILE_DIR"] = &targetFileDirNode;
nodeMap["TARGET_LINKER_FILE_DIR"] = &targetLinkerFileDirNode;
nodeMap["TARGET_SONAME_FILE_DIR"] = &targetSoNameFileDirNode;
nodeMap["STREQUAL"] = &strEqualNode;
nodeMap["EQUAL"] = &equalNode;
nodeMap["LOWER_CASE"] = &lowerCaseNode;
nodeMap["UPPER_CASE"] = &upperCaseNode;
nodeMap["MAKE_C_IDENTIFIER"] = &makeCIdentifierNode;
nodeMap["BOOL"] = &boolNode;
nodeMap["ANGLE-R"] = &angle_rNode;
nodeMap["COMMA"] = &commaNode;
nodeMap["SEMICOLON"] = &semicolonNode;
nodeMap["TARGET_PROPERTY"] = &targetPropertyNode;
nodeMap["TARGET_NAME"] = &targetNameNode;
Genex: Evaluate TARGET_OBJECTS as a normal expression.
2014-02-26 18:59:18 +04:00
nodeMap["TARGET_OBJECTS"] = &targetObjectsNode;
genex: Store predicates as a map for faster searching May warrant a fast path for predicates which more frequently.
2014-02-06 22:59:50 +04:00
nodeMap["TARGET_POLICY"] = &targetPolicyNode;
nodeMap["BUILD_INTERFACE"] = &buildInterfaceNode;
nodeMap["INSTALL_INTERFACE"] = &installInterfaceNode;
nodeMap["INSTALL_PREFIX"] = &installPrefixNode;
nodeMap["JOIN"] = &joinNode;
nodeMap["LINK_ONLY"] = &linkOnlyNode;
}
NodeMap::const_iterator i = nodeMap.find(identifier);
if (i == nodeMap.end())
{
return 0;
}
return i->second;
Add a generator expression for target properties. There are two overloads, so that it can use the operational target when a target property is being evaluated, and a target can alternatively be specified by name. At this point, the generators don't chain. That comes later.
2012-09-12 06:23:31 +04:00
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
}
//----------------------------------------------------------------------------
GeneratorExpressionContent::GeneratorExpressionContent(
const char *startContent,
use size_t for GeneratorExpressionContent::ContentLength to fix some warnings CMake/Source/cmGeneratorExpressionParser.cxx: In member function ‘void cmGeneratorExpressionParser::ParseGeneratorExpression(std::vector<cmGeneratorExpressionEvaluator*>&)’: CMake/Source/cmGeneratorExpressionParser.cxx:116:55: warning: conversion to ‘unsigned int’ from ‘long int’ may alter its value [-Wconversion] CMake/Source/cmGeneratorExpressionParser.cxx:240:39: warning: conversion to ‘int’ from ‘long int’ may alter its value [-Wconversion]
2013-10-21 21:18:16 +04:00
size_t length)
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
: StartContent(startContent), ContentLength(length)
{
}
//----------------------------------------------------------------------------
std::string GeneratorExpressionContent::GetOriginalExpression() const
{
return std::string(this->StartContent, this->ContentLength);
}
Extract the ProcessArbitraryContent method.
2013-04-25 15:54:18 +04:00
//----------------------------------------------------------------------------
std::string GeneratorExpressionContent::ProcessArbitraryContent(
const cmGeneratorExpressionNode *node,
const std::string &identifier,
cmGeneratorExpressionContext *context,
cmGeneratorExpressionDAGChecker *dagChecker,
std::vector<std::vector<cmGeneratorExpressionEvaluator*> >::const_iterator
pit) const
{
std::string result;
const
std::vector<std::vector<cmGeneratorExpressionEvaluator*> >::const_iterator
pend = this->ParamChildren.end();
for ( ; pit != pend; ++pit)
{
std::vector<cmGeneratorExpressionEvaluator*>::const_iterator it
= pit->begin();
const std::vector<cmGeneratorExpressionEvaluator*>::const_iterator end
= pit->end();
for ( ; it != end; ++it)
{
if (node->RequiresLiteralInput())
{
if ((*it)->GetType() != cmGeneratorExpressionEvaluator::Text)
{
reportError(context, this->GetOriginalExpression(),
"$<" + identifier + "> expression requires literal input.");
return std::string();
}
}
result += (*it)->Evaluate(context, dagChecker);
if (context->HadError)
{
return std::string();
}
}
if ((pit + 1) != pend)
{
result += ",";
}
}
if (node->RequiresLiteralInput())
{
std::vector<std::string> parameters;
parameters.push_back(result);
return node->Evaluate(parameters, context, this, dagChecker);
}
return result;
}
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
//----------------------------------------------------------------------------
std::string GeneratorExpressionContent::Evaluate(
Add API to check that dependent target properties form a DAG. Initially this will only be used to check for self-references, but can be extended to check for cycles when chaining properties of other targets.
2012-09-18 15:42:23 +04:00
cmGeneratorExpressionContext *context,
cmGeneratorExpressionDAGChecker *dagChecker) const
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
{
std::string identifier;
{
std::vector<cmGeneratorExpressionEvaluator*>::const_iterator it
= this->IdentifierChildren.begin();
const std::vector<cmGeneratorExpressionEvaluator*>::const_iterator end
= this->IdentifierChildren.end();
for ( ; it != end; ++it)
{
Add API to check that dependent target properties form a DAG. Initially this will only be used to check for self-references, but can be extended to check for cycles when chaining properties of other targets.
2012-09-18 15:42:23 +04:00
identifier += (*it)->Evaluate(context, dagChecker);
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
if (context->HadError)
{
return std::string();
}
}
}
const cmGeneratorExpressionNode *node = GetNode(identifier);
if (!node)
{
reportError(context, this->GetOriginalExpression(),
"Expression did not evaluate to a known generator expression");
return std::string();
}
if (!node->GeneratesContent())
{
Rename the method determining if a genex accepts arbitrary content. The meaning of this will be expanded to generator expressions with more than a single parameter.
2013-04-25 15:28:57 +04:00
if (node->NumExpectedParameters() == 1
&& node->AcceptsArbitraryContentParameter())
Genex: Ensure that $<0:...> has a parameter.
2012-11-27 01:43:13 +04:00
{
if (this->ParamChildren.empty())
{
reportError(context, this->GetOriginalExpression(),
"$<" + identifier + "> expression requires a parameter.");
}
}
else
{
std::vector<std::string> parameters;
this->EvaluateParameters(node, identifier, context, dagChecker,
parameters);
}
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
return std::string();
}
std::vector<std::string> parameters;
Genex: Extract a method to parse parameters.
2012-11-27 01:42:00 +04:00
this->EvaluateParameters(node, identifier, context, dagChecker, parameters);
if (context->HadError)
{
return std::string();
}
return node->Evaluate(parameters, context, this, dagChecker);
}
//----------------------------------------------------------------------------
std::string GeneratorExpressionContent::EvaluateParameters(
const cmGeneratorExpressionNode *node,
const std::string &identifier,
cmGeneratorExpressionContext *context,
cmGeneratorExpressionDAGChecker *dagChecker,
std::vector<std::string> &parameters) const
{
Make it possible for any genex to have arbitrary content at the end.
2013-04-25 15:54:57 +04:00
const int numExpected = node->NumExpectedParameters();
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
{
std::vector<std::vector<cmGeneratorExpressionEvaluator*> >::const_iterator
pit = this->ParamChildren.begin();
const
std::vector<std::vector<cmGeneratorExpressionEvaluator*> >::const_iterator
pend = this->ParamChildren.end();
Make it possible for any genex to have arbitrary content at the end.
2013-04-25 15:54:57 +04:00
const bool acceptsArbitraryContent
= node->AcceptsArbitraryContentParameter();
Genex: Allow single param expressions to accept arbirary input. Existing single-parameter expressions work due to special casing which assumes that if there is only one parameter, and the node accepts arbitrary content, then the result is the input. This is true for the existing expressions matching that pattern - namely the "1" and "TARGET_NAME" expressions. However, the LOWER_CASE, and UPPER_CASE expressions should also accept arbitrary content, and in their case, the result is not the input. Refactor the cmGeneratorExpressionEvaluator to allow that extension. Actually evaluate the "1" and "0" nodes.
2013-12-18 03:32:35 +04:00
int counter = 1;
for ( ; pit != pend; ++pit, ++counter)
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
{
Genex: Allow single param expressions to accept arbirary input. Existing single-parameter expressions work due to special casing which assumes that if there is only one parameter, and the node accepts arbitrary content, then the result is the input. This is true for the existing expressions matching that pattern - namely the "1" and "TARGET_NAME" expressions. However, the LOWER_CASE, and UPPER_CASE expressions should also accept arbitrary content, and in their case, the result is not the input. Refactor the cmGeneratorExpressionEvaluator to allow that extension. Actually evaluate the "1" and "0" nodes.
2013-12-18 03:32:35 +04:00
if (acceptsArbitraryContent && counter == numExpected)
Make it possible for any genex to have arbitrary content at the end.
2013-04-25 15:54:57 +04:00
{
std::string lastParam = this->ProcessArbitraryContent(node, identifier,
context,
dagChecker,
Genex: Allow single param expressions to accept arbirary input. Existing single-parameter expressions work due to special casing which assumes that if there is only one parameter, and the node accepts arbitrary content, then the result is the input. This is true for the existing expressions matching that pattern - namely the "1" and "TARGET_NAME" expressions. However, the LOWER_CASE, and UPPER_CASE expressions should also accept arbitrary content, and in their case, the result is not the input. Refactor the cmGeneratorExpressionEvaluator to allow that extension. Actually evaluate the "1" and "0" nodes.
2013-12-18 03:32:35 +04:00
pit);
Make it possible for any genex to have arbitrary content at the end.
2013-04-25 15:54:57 +04:00
parameters.push_back(lastParam);
return std::string();
}
Genex: Allow single param expressions to accept arbirary input. Existing single-parameter expressions work due to special casing which assumes that if there is only one parameter, and the node accepts arbitrary content, then the result is the input. This is true for the existing expressions matching that pattern - namely the "1" and "TARGET_NAME" expressions. However, the LOWER_CASE, and UPPER_CASE expressions should also accept arbitrary content, and in their case, the result is not the input. Refactor the cmGeneratorExpressionEvaluator to allow that extension. Actually evaluate the "1" and "0" nodes.
2013-12-18 03:32:35 +04:00
else
{
std::string parameter;
std::vector<cmGeneratorExpressionEvaluator*>::const_iterator it =
pit->begin();
const std::vector<cmGeneratorExpressionEvaluator*>::const_iterator end =
pit->end();
for ( ; it != end; ++it)
{
parameter += (*it)->Evaluate(context, dagChecker);
if (context->HadError)
{
return std::string();
}
}
parameters.push_back(parameter);
}
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
}
}
Add $<LINK_LANGUAGE> generator expression They can't be used when evaluating link libraries, but they can be used for include directories and compile definitions. Later they can be used for compile options.
2013-05-16 17:52:25 +04:00
if ((numExpected > cmGeneratorExpressionNode::DynamicParameters
&& (unsigned int)numExpected != parameters.size()))
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
{
if (numExpected == 0)
{
reportError(context, this->GetOriginalExpression(),
"$<" + identifier + "> expression requires no parameters.");
}
else if (numExpected == 1)
{
reportError(context, this->GetOriginalExpression(),
"$<" + identifier + "> expression requires "
"exactly one parameter.");
}
else
{
cmOStringStream e;
e << "$<" + identifier + "> expression requires "
<< numExpected
<< " comma separated parameters, but got "
<< parameters.size() << " instead.";
reportError(context, this->GetOriginalExpression(), e.str());
}
return std::string();
}
Add $<LINK_LANGUAGE> generator expression They can't be used when evaluating link libraries, but they can be used for include directories and compile definitions. Later they can be used for compile options.
2013-05-16 17:52:25 +04:00
if (numExpected == cmGeneratorExpressionNode::OneOrMoreParameters
&& parameters.empty())
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
{
reportError(context, this->GetOriginalExpression(), "$<" + identifier
+ "> expression requires at least one parameter.");
}
Genex: Reform error-checking for nullary/unary expressions. The error messages were incorrect (reporting that the expression requires one or two parameters), and repeated. Remove the now-unused ZeroOrMoreParameters enum value.
2013-12-31 17:28:52 +04:00
if (numExpected == cmGeneratorExpressionNode::OneOrZeroParameters
Genex: Add a nullary form for CONFIG This is consistent with other similar expressions such as PLATFORM_ID, and makes the CONFIGURATION expression obsolete. Fix an off-by-one error in GeneratorExpressionContent::EvaluateParameters exposed by a unit test. Remove the test for 'bad' nullary use of $<CONFIG>. Add a unit test to verify that $<CONFIG> and $<CONFIGURATION> have the same value.
2013-12-31 18:57:25 +04:00
&& parameters.size() > 1)
Genex: Reform error-checking for nullary/unary expressions. The error messages were incorrect (reporting that the expression requires one or two parameters), and repeated. Remove the now-unused ZeroOrMoreParameters enum value.
2013-12-31 17:28:52 +04:00
{
reportError(context, this->GetOriginalExpression(), "$<" + identifier
+ "> expression requires one or zero parameters.");
}
Genex: Extract a method to parse parameters.
2012-11-27 01:42:00 +04:00
return std::string();
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
}
//----------------------------------------------------------------------------
static void deleteAll(const std::vector<cmGeneratorExpressionEvaluator*> &c)
{
std::vector<cmGeneratorExpressionEvaluator*>::const_iterator it
= c.begin();
const std::vector<cmGeneratorExpressionEvaluator*>::const_iterator end
= c.end();
for ( ; it != end; ++it)
{
delete *it;
}
}
//----------------------------------------------------------------------------
GeneratorExpressionContent::~GeneratorExpressionContent()
{
deleteAll(this->IdentifierChildren);
typedef std::vector<cmGeneratorExpressionEvaluator*> EvaluatorVector;
std::vector<EvaluatorVector>::const_iterator pit =
this->ParamChildren.begin();
const std::vector<EvaluatorVector>::const_iterator pend =
this->ParamChildren.end();
for ( ; pit != pend; ++pit)
{
deleteAll(*pit);
}
}