tyler.durden/icinga2
1
0
Fork 0
mirror of https://github.com/Icinga/icinga2.git synced 2025-07-23 05:34:48 +02:00
Code Issues Packages Projects Releases Wiki Activity

Rename AExpression to Expression

Browse Source
This commit is contained in:
Gunnar Beutner 2014-10-16 17:44:06 +02:00
parent 5193ef0fc0
commit feeb550654
17 changed files with 301 additions and 302 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lib/config/CMakeLists.txt
View File

@ -31,10 +31,10 @@ mkembedconfig_target(base-type.conf base-type.cpp)
include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR})
set(config_SOURCES set(config_SOURCES
aexpression.cpp applyrule.cpp base-type.conf base-type.cpp applyrule.cpp base-type.conf base-type.cpp
configcompilercontext.cpp configcompiler.cpp configitembuilder.cpp configcompilercontext.cpp configcompiler.cpp configitembuilder.cpp
configitem.cpp ${FLEX_config_lexer_OUTPUTS} ${BISON_config_parser_OUTPUTS} configitem.cpp ${FLEX_config_lexer_OUTPUTS} ${BISON_config_parser_OUTPUTS}
configtype.cpp objectrule.cpp typerule.cpp typerulelist.cpp configtype.cpp expression.cpp objectrule.cpp typerule.cpp typerulelist.cpp
) )
if(ICINGA2_UNITY_BUILD) if(ICINGA2_UNITY_BUILD)

10
lib/config/applyrule.cpp
View File

@ -27,8 +27,8 @@ using namespace icinga;
ApplyRule::RuleMap ApplyRule::m_Rules; ApplyRule::RuleMap ApplyRule::m_Rules;
ApplyRule::CallbackMap ApplyRule::m_Callbacks; ApplyRule::CallbackMap ApplyRule::m_Callbacks;
ApplyRule::ApplyRule(const String& targetType, const String& name, const AExpression::Ptr& expression, ApplyRule::ApplyRule(const String& targetType, const String& name, const Expression::Ptr& expression,
const AExpression::Ptr& filter, const DebugInfo& di, const Dictionary::Ptr& scope) const Expression::Ptr& filter, const DebugInfo& di, const Dictionary::Ptr& scope)
: m_TargetType(targetType), m_Name(name), m_Expression(expression), m_Filter(filter), m_DebugInfo(di), m_Scope(scope) : m_TargetType(targetType), m_Name(name), m_Expression(expression), m_Filter(filter), m_DebugInfo(di), m_Scope(scope)
{ } { }
@ -42,12 +42,12 @@ String ApplyRule::GetName(void) const
return m_Name; return m_Name;
} }
AExpression::Ptr ApplyRule::GetExpression(void) const Expression::Ptr ApplyRule::GetExpression(void) const
{ {
return m_Expression; return m_Expression;
} }
AExpression::Ptr ApplyRule::GetFilter(void) const Expression::Ptr ApplyRule::GetFilter(void) const
{ {
return m_Filter; return m_Filter;
} }
@ -63,7 +63,7 @@ Dictionary::Ptr ApplyRule::GetScope(void) const
} }
void ApplyRule::AddRule(const String& sourceType, const String& targetType, const String& name, void ApplyRule::AddRule(const String& sourceType, const String& targetType, const String& name,
const AExpression::Ptr& expression, const AExpression::Ptr& filter, const Expression::Ptr& expression, const Expression::Ptr& filter,
const DebugInfo& di, const Dictionary::Ptr& scope) const DebugInfo& di, const Dictionary::Ptr& scope)
{ {
m_Rules[sourceType].push_back(ApplyRule(targetType, name, expression, filter, di, scope)); m_Rules[sourceType].push_back(ApplyRule(targetType, name, expression, filter, di, scope));

18
lib/config/applyrule.hpp
View File

@ -21,7 +21,7 @@
#define APPLYRULE_H #define APPLYRULE_H
#include "config/i2-config.hpp" #include "config/i2-config.hpp"
#include "config/aexpression.hpp" #include "config/expression.hpp"
#include "base/debuginfo.hpp" #include "base/debuginfo.hpp"
#include <boost/function.hpp> #include <boost/function.hpp>
@ -40,15 +40,15 @@ public:
String GetTargetType(void) const; String GetTargetType(void) const;
String GetName(void) const; String GetName(void) const;
AExpression::Ptr GetExpression(void) const; Expression::Ptr GetExpression(void) const;
AExpression::Ptr GetFilter(void) const; Expression::Ptr GetFilter(void) const;
DebugInfo GetDebugInfo(void) const; DebugInfo GetDebugInfo(void) const;
Dictionary::Ptr GetScope(void) const; Dictionary::Ptr GetScope(void) const;
bool EvaluateFilter(const Dictionary::Ptr& scope) const; bool EvaluateFilter(const Dictionary::Ptr& scope) const;
static void AddRule(const String& sourceType, const String& targetType, const String& name, const AExpression::Ptr& expression, static void AddRule(const String& sourceType, const String& targetType, const String& name, const Expression::Ptr& expression,
const AExpression::Ptr& filter, const DebugInfo& di, const Dictionary::Ptr& scope); const Expression::Ptr& filter, const DebugInfo& di, const Dictionary::Ptr& scope);
static void EvaluateRules(bool clear); static void EvaluateRules(bool clear);
static void RegisterType(const String& sourceType, const std::vector<String>& targetTypes, const ApplyRule::Callback& callback); static void RegisterType(const String& sourceType, const std::vector<String>& targetTypes, const ApplyRule::Callback& callback);
@ -59,16 +59,16 @@ public:
private: private:
String m_TargetType; String m_TargetType;
String m_Name; String m_Name;
AExpression::Ptr m_Expression; Expression::Ptr m_Expression;
AExpression::Ptr m_Filter; Expression::Ptr m_Filter;
DebugInfo m_DebugInfo; DebugInfo m_DebugInfo;
Dictionary::Ptr m_Scope; Dictionary::Ptr m_Scope;
static CallbackMap m_Callbacks; static CallbackMap m_Callbacks;
static RuleMap m_Rules; static RuleMap m_Rules;
ApplyRule(const String& targetType, const String& name, const AExpression::Ptr& expression, ApplyRule(const String& targetType, const String& name, const Expression::Ptr& expression,
const AExpression::Ptr& filter, const DebugInfo& di, const Dictionary::Ptr& scope); const Expression::Ptr& filter, const DebugInfo& di, const Dictionary::Ptr& scope);
}; };
} }

48
lib/config/config_lexer.ll
View File

@ -21,7 +21,7 @@
#include "config/configcompiler.hpp" #include "config/configcompiler.hpp"
#include "config/typerule.hpp" #include "config/typerule.hpp"
#include "config/configcompilercontext.hpp" #include "config/configcompilercontext.hpp"
#include "config/aexpression.hpp" #include "config/expression.hpp"
using namespace icinga; using namespace icinga;
@ -233,16 +233,16 @@ __function return T_FUNCTION;
__return return T_RETURN; __return return T_RETURN;
zone return T_ZONE; zone return T_ZONE;
__for return T_FOR; __for return T_FOR;
\<\< { yylval->op = &AExpression::OpShiftLeft; return T_SHIFT_LEFT; } \<\< { yylval->op = &Expression::OpShiftLeft; return T_SHIFT_LEFT; }
\>\> { yylval->op = &AExpression::OpShiftRight; return T_SHIFT_RIGHT; } \>\> { yylval->op = &Expression::OpShiftRight; return T_SHIFT_RIGHT; }
\<= { yylval->op = &AExpression::OpLessThanOrEqual; return T_LESS_THAN_OR_EQUAL; } \<= { yylval->op = &Expression::OpLessThanOrEqual; return T_LESS_THAN_OR_EQUAL; }
\>= { yylval->op = &AExpression::OpGreaterThanOrEqual; return T_GREATER_THAN_OR_EQUAL; } \>= { yylval->op = &Expression::OpGreaterThanOrEqual; return T_GREATER_THAN_OR_EQUAL; }
== { yylval->op = &AExpression::OpEqual; return T_EQUAL; } == { yylval->op = &Expression::OpEqual; return T_EQUAL; }
!= { yylval->op = &AExpression::OpNotEqual; return T_NOT_EQUAL; } != { yylval->op = &Expression::OpNotEqual; return T_NOT_EQUAL; }
!in { yylval->op = &AExpression::OpNotIn; return T_NOT_IN; } !in { yylval->op = &Expression::OpNotIn; return T_NOT_IN; }
in { yylval->op = &AExpression::OpIn; return T_IN; } in { yylval->op = &Expression::OpIn; return T_IN; }
&& { yylval->op = &AExpression::OpLogicalAnd; return T_LOGICAL_AND; } && { yylval->op = &Expression::OpLogicalAnd; return T_LOGICAL_AND; }
\|\| { yylval->op = &AExpression::OpLogicalOr; return T_LOGICAL_OR; } \|\| { yylval->op = &Expression::OpLogicalOr; return T_LOGICAL_OR; }
[a-zA-Z_][a-zA-Z0-9\-_]* { yylval->text = strdup(yytext); return T_IDENTIFIER; } [a-zA-Z_][a-zA-Z0-9\-_]* { yylval->text = strdup(yytext); return T_IDENTIFIER; }
@[a-zA-Z_][a-zA-Z0-9\-_]* { yylval->text = strdup(yytext + 1); return T_IDENTIFIER; } @[a-zA-Z_][a-zA-Z0-9\-_]* { yylval->text = strdup(yytext + 1); return T_IDENTIFIER; }
\<[^\>]*\> { yytext[yyleng-1] = '\0'; yylval->text = strdup(yytext + 1); return T_STRING_ANGLE; } \<[^\>]*\> { yytext[yyleng-1] = '\0'; yylval->text = strdup(yytext + 1); return T_STRING_ANGLE; }
@ -252,19 +252,19 @@ in { yylval->op = &AExpression::OpIn; return T_IN; }
-?[0-9]+(\.[0-9]+)?m { yylval->num = strtod(yytext, NULL) * 60; return T_NUMBER; } -?[0-9]+(\.[0-9]+)?m { yylval->num = strtod(yytext, NULL) * 60; return T_NUMBER; }
-?[0-9]+(\.[0-9]+)?s { yylval->num = strtod(yytext, NULL); return T_NUMBER; } -?[0-9]+(\.[0-9]+)?s { yylval->num = strtod(yytext, NULL); return T_NUMBER; }
-?[0-9]+(\.[0-9]+)? { yylval->num = strtod(yytext, NULL); return T_NUMBER; } -?[0-9]+(\.[0-9]+)? { yylval->num = strtod(yytext, NULL); return T_NUMBER; }
= { yylval->op = &AExpression::OpSet; return T_SET; } = { yylval->op = &Expression::OpSet; return T_SET; }
\+= { yylval->op = &AExpression::OpSetPlus; return T_SET_PLUS; } \+= { yylval->op = &Expression::OpSetPlus; return T_SET_PLUS; }
-= { yylval->op = &AExpression::OpSetMinus; return T_SET_MINUS; } -= { yylval->op = &Expression::OpSetMinus; return T_SET_MINUS; }
\*= { yylval->op = &AExpression::OpSetMultiply; return T_SET_MULTIPLY; } \*= { yylval->op = &Expression::OpSetMultiply; return T_SET_MULTIPLY; }
\/= { yylval->op = &AExpression::OpSetDivide; return T_SET_DIVIDE; } \/= { yylval->op = &Expression::OpSetDivide; return T_SET_DIVIDE; }
\+ { yylval->op = &AExpression::OpAdd; return T_PLUS; } \+ { yylval->op = &Expression::OpAdd; return T_PLUS; }
\- { yylval->op = &AExpression::OpSubtract; return T_MINUS; } \- { yylval->op = &Expression::OpSubtract; return T_MINUS; }
\* { yylval->op = &AExpression::OpMultiply; return T_MULTIPLY; } \* { yylval->op = &Expression::OpMultiply; return T_MULTIPLY; }
\/ { yylval->op = &AExpression::OpMultiply; return T_DIVIDE_OP; } \/ { yylval->op = &Expression::OpMultiply; return T_DIVIDE_OP; }
\& { yylval->op = &AExpression::OpBinaryAnd; return T_BINARY_AND; } \& { yylval->op = &Expression::OpBinaryAnd; return T_BINARY_AND; }
\| { yylval->op = &AExpression::OpBinaryOr; return T_BINARY_OR; } \| { yylval->op = &Expression::OpBinaryOr; return T_BINARY_OR; }
\< { yylval->op = &AExpression::OpLessThan; return T_LESS_THAN; } \< { yylval->op = &Expression::OpLessThan; return T_LESS_THAN; }
\> { yylval->op = &AExpression::OpLessThan; return T_GREATER_THAN; } \> { yylval->op = &Expression::OpLessThan; return T_GREATER_THAN; }
} }
[\r\n]+ { yycolumn -= strlen(yytext) - 1; if (!ignore_newlines) return T_NEWLINE; } [\r\n]+ { yycolumn -= strlen(yytext) - 1; if (!ignore_newlines) return T_NEWLINE; }

143
lib/config/config_parser.yy
View File

@ -27,10 +27,9 @@
#include "config/configcompilercontext.hpp" #include "config/configcompilercontext.hpp"
#include "config/typerule.hpp" #include "config/typerule.hpp"
#include "config/typerulelist.hpp" #include "config/typerulelist.hpp"
#include "config/aexpression.hpp" #include "config/expression.hpp"
#include "config/applyrule.hpp" #include "config/applyrule.hpp"
#include "config/objectrule.hpp" #include "config/objectrule.hpp"
#include "config/aexpression.hpp"
#include "base/value.hpp" #include "base/value.hpp"
#include "base/utility.hpp" #include "base/utility.hpp"
#include "base/array.hpp" #include "base/array.hpp"
@ -74,9 +73,9 @@ using namespace icinga;
int ignore_newlines = 0; int ignore_newlines = 0;
static void MakeRBinaryOp(Value** result, AExpression::OpCallback& op, Value *left, Value *right, DebugInfo& diLeft, DebugInfo& diRight) static void MakeRBinaryOp(Value** result, Expression::OpCallback& op, Value *left, Value *right, DebugInfo& diLeft, DebugInfo& diRight)
{ {
*result = new Value(make_shared<AExpression>(op, *left, *right, DebugInfoRange(diLeft, diRight))); *result = new Value(make_shared<Expression>(op, *left, *right, DebugInfoRange(diLeft, diRight)));
delete left; delete left;
delete right; delete right;
} }
@ -96,7 +95,7 @@ static void MakeRBinaryOp(Value** result, AExpression::OpCallback& op, Value *le
char *text; char *text;
double num; double num;
icinga::Value *variant; icinga::Value *variant;
icinga::AExpression::OpCallback op; icinga::Expression::OpCallback op;
icinga::TypeSpecifier type; icinga::TypeSpecifier type;
std::vector<String> *slist; std::vector<String> *slist;
Array *array; Array *array;
@ -221,8 +220,8 @@ static int m_StatementNum;
static bool m_Apply; static bool m_Apply;
static bool m_ObjectAssign; static bool m_ObjectAssign;
static bool m_SeenAssign; static bool m_SeenAssign;
static AExpression::Ptr m_Assign; static Expression::Ptr m_Assign;
static AExpression::Ptr m_Ignore; static Expression::Ptr m_Ignore;
void ConfigCompiler::Compile(void) void ConfigCompiler::Compile(void)
{ {
@ -260,7 +259,7 @@ statement: type | zone | include | include_recursive | library | constant
{ } { }
| lterm | lterm
{ {
AExpression::Ptr aexpr = *$1; Expression::Ptr aexpr = *$1;
aexpr->Evaluate(m_ModuleScope); aexpr->Evaluate(m_ModuleScope);
delete $1; delete $1;
@ -270,7 +269,7 @@ statement: type | zone | include | include_recursive | library | constant
zone: T_ZONE rterm sep zone: T_ZONE rterm sep
{ {
AExpression::Ptr aexpr = *$2; Expression::Ptr aexpr = *$2;
delete $2; delete $2;
if (!context->GetZone().IsEmpty()) if (!context->GetZone().IsEmpty())
@ -283,7 +282,7 @@ zone: T_ZONE rterm sep
} }
| T_ZONE rterm | T_ZONE rterm
{ {
AExpression::Ptr aexpr = *$2; Expression::Ptr aexpr = *$2;
delete $2; delete $2;
if (!context->GetZone().IsEmpty()) if (!context->GetZone().IsEmpty())
@ -293,7 +292,7 @@ zone: T_ZONE rterm sep
} }
rterm_scope sep rterm_scope sep
{ {
AExpression::Ptr ascope = *$4; Expression::Ptr ascope = *$4;
delete $4; delete $4;
try { try {
@ -307,7 +306,7 @@ zone: T_ZONE rterm sep
include: T_INCLUDE rterm sep include: T_INCLUDE rterm sep
{ {
AExpression::Ptr aexpr = *$2; Expression::Ptr aexpr = *$2;
delete $2; delete $2;
context->HandleInclude(aexpr->Evaluate(m_ModuleScope), false, DebugInfoRange(@1, @2)); context->HandleInclude(aexpr->Evaluate(m_ModuleScope), false, DebugInfoRange(@1, @2));
@ -321,17 +320,17 @@ include: T_INCLUDE rterm sep
include_recursive: T_INCLUDE_RECURSIVE rterm include_recursive: T_INCLUDE_RECURSIVE rterm
{ {
AExpression::Ptr aexpr = *$2; Expression::Ptr aexpr = *$2;
delete $2; delete $2;
context->HandleIncludeRecursive(aexpr->Evaluate(m_ModuleScope), "*.conf", DebugInfoRange(@1, @2)); context->HandleIncludeRecursive(aexpr->Evaluate(m_ModuleScope), "*.conf", DebugInfoRange(@1, @2));
} }
| T_INCLUDE_RECURSIVE rterm ',' rterm | T_INCLUDE_RECURSIVE rterm ',' rterm
{ {
AExpression::Ptr aexpr1 = *$2; Expression::Ptr aexpr1 = *$2;
delete $2; delete $2;
AExpression::Ptr aexpr2 = *$4; Expression::Ptr aexpr2 = *$4;
delete $4; delete $4;
context->HandleIncludeRecursive(aexpr1->Evaluate(m_ModuleScope), aexpr2->Evaluate(m_ModuleScope), DebugInfoRange(@1, @4)); context->HandleIncludeRecursive(aexpr1->Evaluate(m_ModuleScope), aexpr2->Evaluate(m_ModuleScope), DebugInfoRange(@1, @4));
@ -347,7 +346,7 @@ library: T_LIBRARY T_STRING sep
constant: T_CONST identifier T_SET rterm sep constant: T_CONST identifier T_SET rterm sep
{ {
AExpression::Ptr aexpr = *$4; Expression::Ptr aexpr = *$4;
delete $4; delete $4;
ScriptVariable::Ptr sv = ScriptVariable::Set($2, aexpr->Evaluate(m_ModuleScope)); ScriptVariable::Ptr sv = ScriptVariable::Set($2, aexpr->Evaluate(m_ModuleScope));
@ -482,8 +481,8 @@ object:
m_Abstract = false; m_Abstract = false;
m_ObjectAssign = true; m_ObjectAssign = true;
m_SeenAssign = false; m_SeenAssign = false;
m_Assign = make_shared<AExpression>(&AExpression::OpLiteral, false, DebugInfo()); m_Assign = make_shared<Expression>(&Expression::OpLiteral, false, DebugInfo());
m_Ignore = make_shared<AExpression>(&AExpression::OpLiteral, false, DebugInfo()); m_Ignore = make_shared<Expression>(&Expression::OpLiteral, false, DebugInfo());
} }
object_declaration identifier rterm rterm_scope object_declaration identifier rterm rterm_scope
{ {
@ -500,21 +499,21 @@ object:
args->Add(*$4); args->Add(*$4);
delete $4; delete $4;
AExpression::Ptr exprl = *$5; Expression::Ptr exprl = *$5;
delete $5; delete $5;
exprl->MakeInline(); exprl->MakeInline();
if (m_SeenAssign && !ObjectRule::IsValidSourceType(type)) if (m_SeenAssign && !ObjectRule::IsValidSourceType(type))
BOOST_THROW_EXCEPTION(ConfigError("object rule 'assign' cannot be used for type '" + type + "'") << errinfo_debuginfo(DebugInfoRange(@2, @3))); BOOST_THROW_EXCEPTION(ConfigError("object rule 'assign' cannot be used for type '" + type + "'") << errinfo_debuginfo(DebugInfoRange(@2, @3)));
AExpression::Ptr rex = make_shared<AExpression>(&AExpression::OpLogicalNegate, m_Ignore, DebugInfoRange(@2, @5)); Expression::Ptr rex = make_shared<Expression>(&Expression::OpLogicalNegate, m_Ignore, DebugInfoRange(@2, @5));
AExpression::Ptr filter = make_shared<AExpression>(&AExpression::OpLogicalAnd, m_Assign, rex, DebugInfoRange(@2, @5)); Expression::Ptr filter = make_shared<Expression>(&Expression::OpLogicalAnd, m_Assign, rex, DebugInfoRange(@2, @5));
args->Add(filter); args->Add(filter);
args->Add(context->GetZone()); args->Add(context->GetZone());
$$ = new Value(make_shared<AExpression>(&AExpression::OpObject, args, exprl, DebugInfoRange(@2, @5))); $$ = new Value(make_shared<Expression>(&Expression::OpObject, args, exprl, DebugInfoRange(@2, @5)));
m_Assign.reset(); m_Assign.reset();
m_Ignore.reset(); m_Ignore.reset();
@ -602,47 +601,47 @@ lterm_items_inner: lterm
lterm: identifier lbinary_op rterm lterm: identifier lbinary_op rterm
{ {
AExpression::Ptr aindex = make_shared<AExpression>(&AExpression::OpLiteral, $1, @1); Expression::Ptr aindex = make_shared<Expression>(&Expression::OpLiteral, $1, @1);
free($1); free($1);
$$ = new Value(make_shared<AExpression>($2, aindex, *$3, DebugInfoRange(@1, @3))); $$ = new Value(make_shared<Expression>($2, aindex, *$3, DebugInfoRange(@1, @3)));
delete $3; delete $3;
} }
| identifier '[' rterm ']' lbinary_op rterm | identifier '[' rterm ']' lbinary_op rterm
{ {
AExpression::Ptr subexpr = make_shared<AExpression>($5, *$3, *$6, DebugInfoRange(@1, @6)); Expression::Ptr subexpr = make_shared<Expression>($5, *$3, *$6, DebugInfoRange(@1, @6));
delete $3; delete $3;
delete $6; delete $6;
Array::Ptr subexprl = make_shared<Array>(); Array::Ptr subexprl = make_shared<Array>();
subexprl->Add(subexpr); subexprl->Add(subexpr);
AExpression::Ptr aindex = make_shared<AExpression>(&AExpression::OpLiteral, $1, @1); Expression::Ptr aindex = make_shared<Expression>(&Expression::OpLiteral, $1, @1);
free($1); free($1);
AExpression::Ptr expr = make_shared<AExpression>(&AExpression::OpDict, subexprl, DebugInfoRange(@1, @6)); Expression::Ptr expr = make_shared<Expression>(&Expression::OpDict, subexprl, DebugInfoRange(@1, @6));
$$ = new Value(make_shared<AExpression>(&AExpression::OpSetPlus, aindex, expr, DebugInfoRange(@1, @6))); $$ = new Value(make_shared<Expression>(&Expression::OpSetPlus, aindex, expr, DebugInfoRange(@1, @6)));
} }
| identifier '.' T_IDENTIFIER lbinary_op rterm | identifier '.' T_IDENTIFIER lbinary_op rterm
{ {
AExpression::Ptr aindex = make_shared<AExpression>(&AExpression::OpLiteral, $3, @3); Expression::Ptr aindex = make_shared<Expression>(&Expression::OpLiteral, $3, @3);
AExpression::Ptr subexpr = make_shared<AExpression>($4, aindex, *$5, DebugInfoRange(@1, @5)); Expression::Ptr subexpr = make_shared<Expression>($4, aindex, *$5, DebugInfoRange(@1, @5));
free($3); free($3);
delete $5; delete $5;
Array::Ptr subexprl = make_shared<Array>(); Array::Ptr subexprl = make_shared<Array>();
subexprl->Add(subexpr); subexprl->Add(subexpr);
AExpression::Ptr aindexl = make_shared<AExpression>(&AExpression::OpLiteral, $1, @1); Expression::Ptr aindexl = make_shared<Expression>(&Expression::OpLiteral, $1, @1);
free($1); free($1);
AExpression::Ptr expr = make_shared<AExpression>(&AExpression::OpDict, subexprl, DebugInfoRange(@1, @5)); Expression::Ptr expr = make_shared<Expression>(&Expression::OpDict, subexprl, DebugInfoRange(@1, @5));
$$ = new Value(make_shared<AExpression>(&AExpression::OpSetPlus, aindexl, expr, DebugInfoRange(@1, @5))); $$ = new Value(make_shared<Expression>(&Expression::OpSetPlus, aindexl, expr, DebugInfoRange(@1, @5)));
} }
| T_IMPORT rterm | T_IMPORT rterm
{ {
AExpression::Ptr avar = make_shared<AExpression>(&AExpression::OpVariable, "type", DebugInfoRange(@1, @2)); Expression::Ptr avar = make_shared<Expression>(&Expression::OpVariable, "type", DebugInfoRange(@1, @2));
$$ = new Value(make_shared<AExpression>(&AExpression::OpImport, avar, *$2, DebugInfoRange(@1, @2))); $$ = new Value(make_shared<Expression>(&Expression::OpImport, avar, *$2, DebugInfoRange(@1, @2)));
delete $2; delete $2;
} }
| T_ASSIGN T_WHERE rterm | T_ASSIGN T_WHERE rterm
@ -652,26 +651,26 @@ lterm: identifier lbinary_op rterm
m_SeenAssign = true; m_SeenAssign = true;
m_Assign = make_shared<AExpression>(&AExpression::OpLogicalOr, m_Assign, *$3, DebugInfoRange(@1, @3)); m_Assign = make_shared<Expression>(&Expression::OpLogicalOr, m_Assign, *$3, DebugInfoRange(@1, @3));
delete $3; delete $3;
$$ = new Value(make_shared<AExpression>(&AExpression::OpLiteral, Empty, DebugInfoRange(@1, @3))); $$ = new Value(make_shared<Expression>(&Expression::OpLiteral, Empty, DebugInfoRange(@1, @3)));
} }
| T_IGNORE T_WHERE rterm | T_IGNORE T_WHERE rterm
{ {
if (!(m_Apply || m_ObjectAssign)) if (!(m_Apply || m_ObjectAssign))
BOOST_THROW_EXCEPTION(ConfigError("'ignore' keyword not valid in this context.")); BOOST_THROW_EXCEPTION(ConfigError("'ignore' keyword not valid in this context."));
m_Ignore = make_shared<AExpression>(&AExpression::OpLogicalOr, m_Ignore, *$3, DebugInfoRange(@1, @3)); m_Ignore = make_shared<Expression>(&Expression::OpLogicalOr, m_Ignore, *$3, DebugInfoRange(@1, @3));
delete $3; delete $3;
$$ = new Value(make_shared<AExpression>(&AExpression::OpLiteral, Empty, DebugInfoRange(@1, @3))); $$ = new Value(make_shared<Expression>(&Expression::OpLiteral, Empty, DebugInfoRange(@1, @3)));
} }
| T_RETURN rterm | T_RETURN rterm
{ {
AExpression::Ptr aname = make_shared<AExpression>(&AExpression::OpLiteral, "__result", @1); Expression::Ptr aname = make_shared<Expression>(&Expression::OpLiteral, "__result", @1);
$$ = new Value(make_shared<AExpression>(&AExpression::OpSet, aname, *$2, DebugInfoRange(@1, @2))); $$ = new Value(make_shared<Expression>(&Expression::OpSet, aname, *$2, DebugInfoRange(@1, @2)));
delete $2; delete $2;
} }
@ -719,83 +718,83 @@ rterm_items_inner: rterm
rterm_array: '[' newlines rterm_items newlines ']' rterm_array: '[' newlines rterm_items newlines ']'
{ {
$$ = new Value(make_shared<AExpression>(&AExpression::OpArray, Array::Ptr($3), DebugInfoRange(@1, @5))); $$ = new Value(make_shared<Expression>(&Expression::OpArray, Array::Ptr($3), DebugInfoRange(@1, @5)));
} }
| '[' newlines rterm_items ']' | '[' newlines rterm_items ']'
{ {
$$ = new Value(make_shared<AExpression>(&AExpression::OpArray, Array::Ptr($3), DebugInfoRange(@1, @4))); $$ = new Value(make_shared<Expression>(&Expression::OpArray, Array::Ptr($3), DebugInfoRange(@1, @4)));
} }
| '[' rterm_items newlines ']' | '[' rterm_items newlines ']'
{ {
$$ = new Value(make_shared<AExpression>(&AExpression::OpArray, Array::Ptr($2), DebugInfoRange(@1, @4))); $$ = new Value(make_shared<Expression>(&Expression::OpArray, Array::Ptr($2), DebugInfoRange(@1, @4)));
} }
| '[' rterm_items ']' | '[' rterm_items ']'
{ {
$$ = new Value(make_shared<AExpression>(&AExpression::OpArray, Array::Ptr($2), DebugInfoRange(@1, @3))); $$ = new Value(make_shared<Expression>(&Expression::OpArray, Array::Ptr($2), DebugInfoRange(@1, @3)));
} }
; ;
rterm_scope: '{' newlines lterm_items newlines '}' rterm_scope: '{' newlines lterm_items newlines '}'
{ {
$$ = new Value(make_shared<AExpression>(&AExpression::OpDict, Array::Ptr($3), DebugInfoRange(@1, @5))); $$ = new Value(make_shared<Expression>(&Expression::OpDict, Array::Ptr($3), DebugInfoRange(@1, @5)));
} }
| '{' newlines lterm_items '}' | '{' newlines lterm_items '}'
{ {
$$ = new Value(make_shared<AExpression>(&AExpression::OpDict, Array::Ptr($3), DebugInfoRange(@1, @4))); $$ = new Value(make_shared<Expression>(&Expression::OpDict, Array::Ptr($3), DebugInfoRange(@1, @4)));
} }
| '{' lterm_items newlines '}' | '{' lterm_items newlines '}'
{ {
$$ = new Value(make_shared<AExpression>(&AExpression::OpDict, Array::Ptr($2), DebugInfoRange(@1, @4))); $$ = new Value(make_shared<Expression>(&Expression::OpDict, Array::Ptr($2), DebugInfoRange(@1, @4)));
} }
| '{' lterm_items '}' | '{' lterm_items '}'
{ {
$$ = new Value(make_shared<AExpression>(&AExpression::OpDict, Array::Ptr($2), DebugInfoRange(@1, @3))); $$ = new Value(make_shared<Expression>(&Expression::OpDict, Array::Ptr($2), DebugInfoRange(@1, @3)));
} }
; ;
rterm: T_STRING rterm: T_STRING
{ {
$$ = new Value(make_shared<AExpression>(&AExpression::OpLiteral, $1, @1)); $$ = new Value(make_shared<Expression>(&Expression::OpLiteral, $1, @1));
free($1); free($1);
} }
| T_NUMBER | T_NUMBER
{ {
$$ = new Value(make_shared<AExpression>(&AExpression::OpLiteral, $1, @1)); $$ = new Value(make_shared<Expression>(&Expression::OpLiteral, $1, @1));
} }
| T_NULL | T_NULL
{ {
$$ = new Value(make_shared<AExpression>(&AExpression::OpLiteral, Empty, @1)); $$ = new Value(make_shared<Expression>(&Expression::OpLiteral, Empty, @1));
} }
| rterm '.' T_IDENTIFIER | rterm '.' T_IDENTIFIER
{ {
$$ = new Value(make_shared<AExpression>(&AExpression::OpIndexer, *$1, make_shared<AExpression>(&AExpression::OpLiteral, $3, @3), DebugInfoRange(@1, @3))); $$ = new Value(make_shared<Expression>(&Expression::OpIndexer, *$1, make_shared<Expression>(&Expression::OpLiteral, $3, @3), DebugInfoRange(@1, @3)));
delete $1; delete $1;
free($3); free($3);
} }
| rterm '(' rterm_items ')' | rterm '(' rterm_items ')'
{ {
Array::Ptr arguments = Array::Ptr($3); Array::Ptr arguments = Array::Ptr($3);
$$ = new Value(make_shared<AExpression>(&AExpression::OpFunctionCall, *$1, make_shared<AExpression>(&AExpression::OpLiteral, arguments, @3), DebugInfoRange(@1, @4))); $$ = new Value(make_shared<Expression>(&Expression::OpFunctionCall, *$1, make_shared<Expression>(&Expression::OpLiteral, arguments, @3), DebugInfoRange(@1, @4)));
delete $1; delete $1;
} }
| T_IDENTIFIER | T_IDENTIFIER
{ {
$$ = new Value(make_shared<AExpression>(&AExpression::OpVariable, $1, @1)); $$ = new Value(make_shared<Expression>(&Expression::OpVariable, $1, @1));
free($1); free($1);
} }
| '!' rterm | '!' rterm
{ {
$$ = new Value(make_shared<AExpression>(&AExpression::OpLogicalNegate, *$2, DebugInfoRange(@1, @2))); $$ = new Value(make_shared<Expression>(&Expression::OpLogicalNegate, *$2, DebugInfoRange(@1, @2)));
delete $2; delete $2;
} }
| '~' rterm | '~' rterm
{ {
$$ = new Value(make_shared<AExpression>(&AExpression::OpNegate, *$2, DebugInfoRange(@1, @2))); $$ = new Value(make_shared<Expression>(&Expression::OpNegate, *$2, DebugInfoRange(@1, @2)));
delete $2; delete $2;
} }
| rterm '[' rterm ']' | rterm '[' rterm ']'
{ {
$$ = new Value(make_shared<AExpression>(&AExpression::OpIndexer, *$1, *$3, DebugInfoRange(@1, @4))); $$ = new Value(make_shared<Expression>(&Expression::OpIndexer, *$1, *$3, DebugInfoRange(@1, @4)));
delete $1; delete $1;
delete $3; delete $3;
} }
@ -841,12 +840,12 @@ rterm: T_STRING
arr->Add($2); arr->Add($2);
free($2); free($2);
AExpression::Ptr aexpr = *$6; Expression::Ptr aexpr = *$6;
delete $6; delete $6;
aexpr->MakeInline(); aexpr->MakeInline();
arr->Add(aexpr); arr->Add(aexpr);
$$ = new Value(make_shared<AExpression>(&AExpression::OpFunction, arr, Array::Ptr($4), DebugInfoRange(@1, @6))); $$ = new Value(make_shared<Expression>(&Expression::OpFunction, arr, Array::Ptr($4), DebugInfoRange(@1, @6)));
} }
| T_FUNCTION '(' identifier_items ')' rterm_scope | T_FUNCTION '(' identifier_items ')' rterm_scope
{ {
@ -854,12 +853,12 @@ rterm: T_STRING
arr->Add(Empty); arr->Add(Empty);
AExpression::Ptr aexpr = *$5; Expression::Ptr aexpr = *$5;
delete $5; delete $5;
aexpr->MakeInline(); aexpr->MakeInline();
arr->Add(aexpr); arr->Add(aexpr);
$$ = new Value(make_shared<AExpression>(&AExpression::OpFunction, arr, Array::Ptr($3), DebugInfoRange(@1, @5))); $$ = new Value(make_shared<Expression>(&Expression::OpFunction, arr, Array::Ptr($3), DebugInfoRange(@1, @5)));
} }
| T_FOR '(' identifier T_IN rterm ')' rterm_scope | T_FOR '(' identifier T_IN rterm ')' rterm_scope
{ {
@ -868,14 +867,14 @@ rterm: T_STRING
arr->Add($3); arr->Add($3);
free($3); free($3);
AExpression::Ptr aexpr = *$5; Expression::Ptr aexpr = *$5;
delete $5; delete $5;
arr->Add(aexpr); arr->Add(aexpr);
AExpression::Ptr ascope = *$7; Expression::Ptr ascope = *$7;
delete $7; delete $7;
$$ = new Value(make_shared<AExpression>(&AExpression::OpFor, arr, ascope, DebugInfoRange(@1, @7))); $$ = new Value(make_shared<Expression>(&Expression::OpFor, arr, ascope, DebugInfoRange(@1, @7)));
} }
; ;
@ -893,8 +892,8 @@ apply:
{ {
m_Apply = true; m_Apply = true;
m_SeenAssign = false; m_SeenAssign = false;
m_Assign = make_shared<AExpression>(&AExpression::OpLiteral, false, DebugInfo()); m_Assign = make_shared<Expression>(&Expression::OpLiteral, false, DebugInfo());
m_Ignore = make_shared<AExpression>(&AExpression::OpLiteral, false, DebugInfo()); m_Ignore = make_shared<Expression>(&Expression::OpLiteral, false, DebugInfo());
} }
T_APPLY identifier rterm target_type_specifier rterm T_APPLY identifier rterm target_type_specifier rterm
{ {
@ -902,7 +901,7 @@ apply:
String type = $3; String type = $3;
free($3); free($3);
AExpression::Ptr aname = *$4; Expression::Ptr aname = *$4;
delete $4; delete $4;
String target = $5; String target = $5;
free($5); free($5);
@ -931,7 +930,7 @@ apply:
BOOST_THROW_EXCEPTION(ConfigError("'apply' target type '" + target + "' is invalid") << errinfo_debuginfo(DebugInfoRange(@2, @5))); BOOST_THROW_EXCEPTION(ConfigError("'apply' target type '" + target + "' is invalid") << errinfo_debuginfo(DebugInfoRange(@2, @5)));
} }
AExpression::Ptr exprl = *$6; Expression::Ptr exprl = *$6;
delete $6; delete $6;
exprl->MakeInline(); exprl->MakeInline();
@ -940,8 +939,8 @@ apply:
if (!m_SeenAssign) if (!m_SeenAssign)
BOOST_THROW_EXCEPTION(ConfigError("'apply' is missing 'assign'") << errinfo_debuginfo(DebugInfoRange(@2, @3))); BOOST_THROW_EXCEPTION(ConfigError("'apply' is missing 'assign'") << errinfo_debuginfo(DebugInfoRange(@2, @3)));
AExpression::Ptr rex = make_shared<AExpression>(&AExpression::OpLogicalNegate, m_Ignore, DebugInfoRange(@2, @5)); Expression::Ptr rex = make_shared<Expression>(&Expression::OpLogicalNegate, m_Ignore, DebugInfoRange(@2, @5));
AExpression::Ptr filter = make_shared<AExpression>(&AExpression::OpLogicalAnd, m_Assign, rex, DebugInfoRange(@2, @5)); Expression::Ptr filter = make_shared<Expression>(&Expression::OpLogicalAnd, m_Assign, rex, DebugInfoRange(@2, @5));
Array::Ptr args = make_shared<Array>(); Array::Ptr args = make_shared<Array>();
args->Add(type); args->Add(type);
@ -949,7 +948,7 @@ apply:
args->Add(aname); args->Add(aname);
args->Add(filter); args->Add(filter);
$$ = new Value(make_shared<AExpression>(&AExpression::OpApply, args, exprl, DebugInfoRange(@2, @5))); $$ = new Value(make_shared<Expression>(&Expression::OpApply, args, exprl, DebugInfoRange(@2, @5)));
m_Assign.reset(); m_Assign.reset();
m_Ignore.reset(); m_Ignore.reset();

4
lib/config/configitem.cpp
View File

@ -53,7 +53,7 @@ ConfigItem::ItemMap ConfigItem::m_Items;
* @param debuginfo Debug information. * @param debuginfo Debug information.
*/ */
ConfigItem::ConfigItem(const String& type, const String& name, ConfigItem::ConfigItem(const String& type, const String& name,
bool abstract, const AExpression::Ptr& exprl, bool abstract, const Expression::Ptr& exprl,
const DebugInfo& debuginfo, const Dictionary::Ptr& scope, const DebugInfo& debuginfo, const Dictionary::Ptr& scope,
const String& zone) const String& zone)
: m_Type(type), m_Name(name), m_Abstract(abstract), m_Validated(false), : m_Type(type), m_Name(name), m_Abstract(abstract), m_Validated(false),
@ -112,7 +112,7 @@ Dictionary::Ptr ConfigItem::GetScope(void) const
* *
* @returns The expression list. * @returns The expression list.
*/ */
AExpression::Ptr ConfigItem::GetExpressionList(void) const Expression::Ptr ConfigItem::GetExpressionList(void) const
{ {
return m_ExpressionList; return m_ExpressionList;
} }

8
lib/config/configitem.hpp
View File

@ -21,7 +21,7 @@
#define CONFIGITEM_H #define CONFIGITEM_H
#include "config/i2-config.hpp" #include "config/i2-config.hpp"
#include "config/aexpression.hpp" #include "config/expression.hpp"
#include "base/dynamicobject.hpp" #include "base/dynamicobject.hpp"
namespace icinga namespace icinga
@ -38,7 +38,7 @@ public:
DECLARE_PTR_TYPEDEFS(ConfigItem); DECLARE_PTR_TYPEDEFS(ConfigItem);
ConfigItem(const String& type, const String& name, bool abstract, ConfigItem(const String& type, const String& name, bool abstract,
const AExpression::Ptr& exprl, const DebugInfo& debuginfo, const Expression::Ptr& exprl, const DebugInfo& debuginfo,
const Dictionary::Ptr& scope, const String& zone); const Dictionary::Ptr& scope, const String& zone);
String GetType(void) const; String GetType(void) const;
@ -47,7 +47,7 @@ public:
std::vector<ConfigItem::Ptr> GetParents(void) const; std::vector<ConfigItem::Ptr> GetParents(void) const;
AExpression::Ptr GetExpressionList(void) const; Expression::Ptr GetExpressionList(void) const;
Dictionary::Ptr GetProperties(void); Dictionary::Ptr GetProperties(void);
Dictionary::Ptr GetDebugHints(void) const; Dictionary::Ptr GetDebugHints(void) const;
@ -77,7 +77,7 @@ private:
bool m_Abstract; /**< Whether this is a template. */ bool m_Abstract; /**< Whether this is a template. */
bool m_Validated; /** Whether this object has been validated. */ bool m_Validated; /** Whether this object has been validated. */
AExpression::Ptr m_ExpressionList; Expression::Ptr m_ExpressionList;
Dictionary::Ptr m_Properties; Dictionary::Ptr m_Properties;
Dictionary::Ptr m_DebugHints; Dictionary::Ptr m_DebugHints;
std::vector<String> m_ParentNames; /**< The names of parent configuration std::vector<String> m_ParentNames; /**< The names of parent configuration

12
lib/config/configitembuilder.cpp
View File

@ -64,7 +64,7 @@ void ConfigItemBuilder::SetZone(const String& zone)
m_Zone = zone; m_Zone = zone;
} }
void ConfigItemBuilder::AddExpression(const AExpression::Ptr& expr) void ConfigItemBuilder::AddExpression(const Expression::Ptr& expr)
{ {
m_Expressions->Add(expr); m_Expressions->Add(expr);
} }
@ -93,14 +93,14 @@ ConfigItem::Ptr ConfigItemBuilder::Compile(void)
Array::Ptr templateArray = make_shared<Array>(); Array::Ptr templateArray = make_shared<Array>();
templateArray->Add(m_Name); templateArray->Add(m_Name);
exprs->Add(make_shared<AExpression>(&AExpression::OpSetPlus, exprs->Add(make_shared<Expression>(&Expression::OpSetPlus,
make_shared<AExpression>(&AExpression::OpLiteral, "templates", m_DebugInfo), make_shared<Expression>(&Expression::OpLiteral, "templates", m_DebugInfo),
make_shared<AExpression>(&AExpression::OpLiteral, templateArray, m_DebugInfo), make_shared<Expression>(&Expression::OpLiteral, templateArray, m_DebugInfo),
m_DebugInfo)); m_DebugInfo));
exprs->Add(make_shared<AExpression>(&AExpression::OpDict, m_Expressions, true, m_DebugInfo)); exprs->Add(make_shared<Expression>(&Expression::OpDict, m_Expressions, true, m_DebugInfo));
AExpression::Ptr exprl = make_shared<AExpression>(&AExpression::OpDict, exprs, true, m_DebugInfo); Expression::Ptr exprl = make_shared<Expression>(&Expression::OpDict, exprs, true, m_DebugInfo);
return make_shared<ConfigItem>(m_Type, m_Name, m_Abstract, exprl, return make_shared<ConfigItem>(m_Type, m_Name, m_Abstract, exprl,
m_DebugInfo, m_Scope, m_Zone); m_DebugInfo, m_Scope, m_Zone);

4
lib/config/configitembuilder.hpp
View File

@ -20,7 +20,7 @@
#ifndef CONFIGITEMBUILDER_H #ifndef CONFIGITEMBUILDER_H
#define CONFIGITEMBUILDER_H #define CONFIGITEMBUILDER_H
#include "config/aexpression.hpp" #include "config/expression.hpp"
#include "config/configitem.hpp" #include "config/configitem.hpp"
#include "base/debuginfo.hpp" #include "base/debuginfo.hpp"
#include "base/object.hpp" #include "base/object.hpp"
@ -48,7 +48,7 @@ public:
void SetScope(const Dictionary::Ptr& scope); void SetScope(const Dictionary::Ptr& scope);
void SetZone(const String& zone); void SetZone(const String& zone);
void AddExpression(const AExpression::Ptr& expr); void AddExpression(const Expression::Ptr& expr);
ConfigItem::Ptr Compile(void); ConfigItem::Ptr Compile(void);

156
lib/config/aexpression.cpp → lib/config/expression.cpp
View File

@ -17,7 +17,7 @@
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. * * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/ ******************************************************************************/
#include "config/aexpression.hpp" #include "config/expression.hpp"
#include "config/configitem.hpp" #include "config/configitem.hpp"
#include "config/configitembuilder.hpp" #include "config/configitembuilder.hpp"
#include "config/applyrule.hpp" #include "config/applyrule.hpp"
@ -37,22 +37,22 @@
using namespace icinga; using namespace icinga;
AExpression::AExpression(OpCallback op, const Value& operand1, const DebugInfo& di) Expression::Expression(OpCallback op, const Value& operand1, const DebugInfo& di)
: m_Operator(op), m_Operand1(operand1), m_Operand2(), m_DebugInfo(di) : m_Operator(op), m_Operand1(operand1), m_Operand2(), m_DebugInfo(di)
{ } { }
AExpression::AExpression(OpCallback op, const Value& operand1, const Value& operand2, const DebugInfo& di) Expression::Expression(OpCallback op, const Value& operand1, const Value& operand2, const DebugInfo& di)
: m_Operator(op), m_Operand1(operand1), m_Operand2(operand2), m_DebugInfo(di) : m_Operator(op), m_Operand1(operand1), m_Operand2(operand2), m_DebugInfo(di)
{ } { }
Value AExpression::Evaluate(const Dictionary::Ptr& locals, DebugHint *dhint) const Value Expression::Evaluate(const Dictionary::Ptr& locals, DebugHint *dhint) const
{ {
try { try {
#ifdef _DEBUG #ifdef _DEBUG
if (m_Operator != &AExpression::OpLiteral) { if (m_Operator != &Expression::OpLiteral) {
std::ostringstream msgbuf; std::ostringstream msgbuf;
ShowCodeFragment(msgbuf, m_DebugInfo, false); ShowCodeFragment(msgbuf, m_DebugInfo, false);
Log(LogDebug, "AExpression", "Executing:\n" + msgbuf.str()); Log(LogDebug, "Expression", "Executing:\n" + msgbuf.str());
} }
#endif /* _DEBUG */ #endif /* _DEBUG */
@ -65,13 +65,13 @@ Value AExpression::Evaluate(const Dictionary::Ptr& locals, DebugHint *dhint) con
} }
} }
void AExpression::MakeInline(void) void Expression::MakeInline(void)
{ {
if (m_Operator == &AExpression::OpDict) if (m_Operator == &Expression::OpDict)
m_Operand2 = true; m_Operand2 = true;
} }
void AExpression::DumpOperand(std::ostream& stream, const Value& operand, int indent) { void Expression::DumpOperand(std::ostream& stream, const Value& operand, int indent) {
if (operand.IsObjectType<Array>()) { if (operand.IsObjectType<Array>()) {
Array::Ptr arr = operand; Array::Ptr arr = operand;
stream << String(indent, ' ') << "Array:\n"; stream << String(indent, ' ') << "Array:\n";
@ -79,15 +79,15 @@ void AExpression::DumpOperand(std::ostream& stream, const Value& operand, int in
BOOST_FOREACH(const Value& elem, arr) { BOOST_FOREACH(const Value& elem, arr) {
DumpOperand(stream, elem, indent + 1); DumpOperand(stream, elem, indent + 1);
} }
} else if (operand.IsObjectType<AExpression>()) { } else if (operand.IsObjectType<Expression>()) {
AExpression::Ptr left = operand; Expression::Ptr left = operand;
left->Dump(stream, indent); left->Dump(stream, indent);
} else { } else {
stream << String(indent, ' ') << JsonSerialize(operand) << "\n"; stream << String(indent, ' ') << JsonSerialize(operand) << "\n";
} }
} }
void AExpression::Dump(std::ostream& stream, int indent) const void Expression::Dump(std::ostream& stream, int indent) const
{ {
String sym = Utility::GetSymbolName(reinterpret_cast<const void *>(m_Operator)); String sym = Utility::GetSymbolName(reinterpret_cast<const void *>(m_Operator));
stream << String(indent, ' ') << "op: " << Utility::DemangleSymbolName(sym) << "\n"; stream << String(indent, ' ') << "op: " << Utility::DemangleSymbolName(sym) << "\n";
@ -98,22 +98,22 @@ void AExpression::Dump(std::ostream& stream, int indent) const
DumpOperand(stream, m_Operand2, indent + 1); DumpOperand(stream, m_Operand2, indent + 1);
} }
Value AExpression::EvaluateOperand1(const Dictionary::Ptr& locals, DebugHint *dhint) const Value Expression::EvaluateOperand1(const Dictionary::Ptr& locals, DebugHint *dhint) const
{ {
return static_cast<AExpression::Ptr>(m_Operand1)->Evaluate(locals, dhint); return static_cast<Expression::Ptr>(m_Operand1)->Evaluate(locals, dhint);
} }
Value AExpression::EvaluateOperand2(const Dictionary::Ptr& locals, DebugHint *dhint) const Value Expression::EvaluateOperand2(const Dictionary::Ptr& locals, DebugHint *dhint) const
{ {
return static_cast<AExpression::Ptr>(m_Operand2)->Evaluate(locals, dhint); return static_cast<Expression::Ptr>(m_Operand2)->Evaluate(locals, dhint);
} }
Value AExpression::OpLiteral(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpLiteral(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
return expr->m_Operand1; return expr->m_Operand1;
} }
Value AExpression::OpVariable(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpVariable(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
Dictionary::Ptr scope = locals; Dictionary::Ptr scope = locals;
@ -127,87 +127,87 @@ Value AExpression::OpVariable(const AExpression *expr, const Dictionary::Ptr& lo
return ScriptVariable::Get(expr->m_Operand1); return ScriptVariable::Get(expr->m_Operand1);
} }
Value AExpression::OpNegate(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpNegate(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
return ~(long)expr->EvaluateOperand1(locals); return ~(long)expr->EvaluateOperand1(locals);
} }
Value AExpression::OpLogicalNegate(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpLogicalNegate(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
return !expr->EvaluateOperand1(locals).ToBool(); return !expr->EvaluateOperand1(locals).ToBool();
} }
Value AExpression::OpAdd(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpAdd(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
return expr->EvaluateOperand1(locals) + expr->EvaluateOperand2(locals); return expr->EvaluateOperand1(locals) + expr->EvaluateOperand2(locals);
} }
Value AExpression::OpSubtract(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpSubtract(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
return expr->EvaluateOperand1(locals) - expr->EvaluateOperand2(locals); return expr->EvaluateOperand1(locals) - expr->EvaluateOperand2(locals);
} }
Value AExpression::OpMultiply(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpMultiply(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
return expr->EvaluateOperand1(locals) * expr->EvaluateOperand2(locals); return expr->EvaluateOperand1(locals) * expr->EvaluateOperand2(locals);
} }
Value AExpression::OpDivide(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpDivide(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
return expr->EvaluateOperand1(locals) / expr->EvaluateOperand2(locals); return expr->EvaluateOperand1(locals) / expr->EvaluateOperand2(locals);
} }
Value AExpression::OpBinaryAnd(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpBinaryAnd(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
return expr->EvaluateOperand1(locals) & expr->EvaluateOperand2(locals); return expr->EvaluateOperand1(locals) & expr->EvaluateOperand2(locals);
} }
Value AExpression::OpBinaryOr(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpBinaryOr(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
return expr->EvaluateOperand1(locals) | expr->EvaluateOperand2(locals); return expr->EvaluateOperand1(locals) | expr->EvaluateOperand2(locals);
} }
Value AExpression::OpShiftLeft(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpShiftLeft(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
return expr->EvaluateOperand1(locals) << expr->EvaluateOperand2(locals); return expr->EvaluateOperand1(locals) << expr->EvaluateOperand2(locals);
} }
Value AExpression::OpShiftRight(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpShiftRight(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
return expr->EvaluateOperand1(locals) >> expr->EvaluateOperand2(locals); return expr->EvaluateOperand1(locals) >> expr->EvaluateOperand2(locals);
} }
Value AExpression::OpEqual(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpEqual(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
return expr->EvaluateOperand1(locals) == expr->EvaluateOperand2(locals); return expr->EvaluateOperand1(locals) == expr->EvaluateOperand2(locals);
} }
Value AExpression::OpNotEqual(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpNotEqual(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
return expr->EvaluateOperand1(locals) != expr->EvaluateOperand2(locals); return expr->EvaluateOperand1(locals) != expr->EvaluateOperand2(locals);
} }
Value AExpression::OpLessThan(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpLessThan(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
return expr->EvaluateOperand1(locals) < expr->EvaluateOperand2(locals); return expr->EvaluateOperand1(locals) < expr->EvaluateOperand2(locals);
} }
Value AExpression::OpGreaterThan(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpGreaterThan(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
return expr->EvaluateOperand1(locals) > expr->EvaluateOperand2(locals); return expr->EvaluateOperand1(locals) > expr->EvaluateOperand2(locals);
} }
Value AExpression::OpLessThanOrEqual(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpLessThanOrEqual(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
return expr->EvaluateOperand1(locals) <= expr->EvaluateOperand2(locals); return expr->EvaluateOperand1(locals) <= expr->EvaluateOperand2(locals);
} }
Value AExpression::OpGreaterThanOrEqual(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpGreaterThanOrEqual(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
return expr->EvaluateOperand1(locals) >= expr->EvaluateOperand2(locals); return expr->EvaluateOperand1(locals) >= expr->EvaluateOperand2(locals);
} }
Value AExpression::OpIn(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpIn(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
Value right = expr->EvaluateOperand2(locals); Value right = expr->EvaluateOperand2(locals);
@ -231,22 +231,22 @@ Value AExpression::OpIn(const AExpression *expr, const Dictionary::Ptr& locals,
return found; return found;
} }
Value AExpression::OpNotIn(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpNotIn(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
return !OpIn(expr, locals, dhint); return !OpIn(expr, locals, dhint);
} }
Value AExpression::OpLogicalAnd(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpLogicalAnd(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
return expr->EvaluateOperand1(locals).ToBool() && expr->EvaluateOperand2(locals).ToBool(); return expr->EvaluateOperand1(locals).ToBool() && expr->EvaluateOperand2(locals).ToBool();
} }
Value AExpression::OpLogicalOr(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpLogicalOr(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
return expr->EvaluateOperand1(locals).ToBool() || expr->EvaluateOperand2(locals).ToBool(); return expr->EvaluateOperand1(locals).ToBool() || expr->EvaluateOperand2(locals).ToBool();
} }
Value AExpression::OpFunctionCall(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpFunctionCall(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
Value funcName = expr->EvaluateOperand1(locals); Value funcName = expr->EvaluateOperand1(locals);
@ -263,21 +263,21 @@ Value AExpression::OpFunctionCall(const AExpression *expr, const Dictionary::Ptr
Array::Ptr arr = expr->EvaluateOperand2(locals); Array::Ptr arr = expr->EvaluateOperand2(locals);
std::vector<Value> arguments; std::vector<Value> arguments;
for (Array::SizeType index = 0; index < arr->GetLength(); index++) { for (Array::SizeType index = 0; index < arr->GetLength(); index++) {
const AExpression::Ptr& aexpr = arr->Get(index); const Expression::Ptr& aexpr = arr->Get(index);
arguments.push_back(aexpr->Evaluate(locals)); arguments.push_back(aexpr->Evaluate(locals));
} }
return func->Invoke(arguments); return func->Invoke(arguments);
} }
Value AExpression::OpArray(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpArray(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
Array::Ptr arr = expr->m_Operand1; Array::Ptr arr = expr->m_Operand1;
Array::Ptr result = make_shared<Array>(); Array::Ptr result = make_shared<Array>();
if (arr) { if (arr) {
for (Array::SizeType index = 0; index < arr->GetLength(); index++) { for (Array::SizeType index = 0; index < arr->GetLength(); index++) {
const AExpression::Ptr& aexpr = arr->Get(index); const Expression::Ptr& aexpr = arr->Get(index);
result->Add(aexpr->Evaluate(locals)); result->Add(aexpr->Evaluate(locals));
} }
} }
@ -285,7 +285,7 @@ Value AExpression::OpArray(const AExpression *expr, const Dictionary::Ptr& local
return result; return result;
} }
Value AExpression::OpDict(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpDict(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
Array::Ptr arr = expr->m_Operand1; Array::Ptr arr = expr->m_Operand1;
bool in_place = expr->m_Operand2; bool in_place = expr->m_Operand2;
@ -295,7 +295,7 @@ Value AExpression::OpDict(const AExpression *expr, const Dictionary::Ptr& locals
if (arr) { if (arr) {
for (Array::SizeType index = 0; index < arr->GetLength(); index++) { for (Array::SizeType index = 0; index < arr->GetLength(); index++) {
const AExpression::Ptr& aexpr = arr->Get(index); const Expression::Ptr& aexpr = arr->Get(index);
Dictionary::Ptr alocals = in_place ? locals : result; Dictionary::Ptr alocals = in_place ? locals : result;
aexpr->Evaluate(alocals, dhint); aexpr->Evaluate(alocals, dhint);
@ -309,7 +309,7 @@ Value AExpression::OpDict(const AExpression *expr, const Dictionary::Ptr& locals
return xresult; return xresult;
} }
Value AExpression::OpSet(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpSet(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
Value index = expr->EvaluateOperand1(locals); Value index = expr->EvaluateOperand1(locals);
@ -326,14 +326,14 @@ Value AExpression::OpSet(const AExpression *expr, const Dictionary::Ptr& locals,
return right; return right;
} }
Value AExpression::OpSetPlus(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpSetPlus(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
Value index = expr->EvaluateOperand1(locals); Value index = expr->EvaluateOperand1(locals);
Value left = locals->Get(index); Value left = locals->Get(index);
AExpression::Ptr exp_right = expr->m_Operand2; Expression::Ptr exp_right = expr->m_Operand2;
Dictionary::Ptr xlocals = locals; Dictionary::Ptr xlocals = locals;
if (exp_right->m_Operator == &AExpression::OpDict) { if (exp_right->m_Operator == &Expression::OpDict) {
xlocals = left; xlocals = left;
if (!xlocals) if (!xlocals)
@ -348,7 +348,7 @@ Value AExpression::OpSetPlus(const AExpression *expr, const Dictionary::Ptr& loc
Value result = left + expr->EvaluateOperand2(xlocals, sdhint); Value result = left + expr->EvaluateOperand2(xlocals, sdhint);
if (exp_right->m_Operator == &AExpression::OpDict) { if (exp_right->m_Operator == &Expression::OpDict) {
Dictionary::Ptr dict = result; Dictionary::Ptr dict = result;
dict->Remove("__parent"); dict->Remove("__parent");
} }
@ -361,14 +361,14 @@ Value AExpression::OpSetPlus(const AExpression *expr, const Dictionary::Ptr& loc
return result; return result;
} }
Value AExpression::OpSetMinus(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpSetMinus(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
Value index = expr->EvaluateOperand1(locals); Value index = expr->EvaluateOperand1(locals);
Value left = locals->Get(index); Value left = locals->Get(index);
AExpression::Ptr exp_right = expr->m_Operand2; Expression::Ptr exp_right = expr->m_Operand2;
Dictionary::Ptr xlocals = locals; Dictionary::Ptr xlocals = locals;
if (exp_right->m_Operator == &AExpression::OpDict) { if (exp_right->m_Operator == &Expression::OpDict) {
xlocals = left; xlocals = left;
if (!xlocals) if (!xlocals)
@ -383,7 +383,7 @@ Value AExpression::OpSetMinus(const AExpression *expr, const Dictionary::Ptr& lo
Value result = left - expr->EvaluateOperand2(xlocals, sdhint); Value result = left - expr->EvaluateOperand2(xlocals, sdhint);
if (exp_right->m_Operator == &AExpression::OpDict) { if (exp_right->m_Operator == &Expression::OpDict) {
Dictionary::Ptr dict = result; Dictionary::Ptr dict = result;
dict->Remove("__parent"); dict->Remove("__parent");
} }
@ -396,14 +396,14 @@ Value AExpression::OpSetMinus(const AExpression *expr, const Dictionary::Ptr& lo
return result; return result;
} }
Value AExpression::OpSetMultiply(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpSetMultiply(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
Value index = expr->EvaluateOperand1(locals); Value index = expr->EvaluateOperand1(locals);
Value left = locals->Get(index); Value left = locals->Get(index);
AExpression::Ptr exp_right = expr->m_Operand2; Expression::Ptr exp_right = expr->m_Operand2;
Dictionary::Ptr xlocals = locals; Dictionary::Ptr xlocals = locals;
if (exp_right->m_Operator == &AExpression::OpDict) { if (exp_right->m_Operator == &Expression::OpDict) {
xlocals = left; xlocals = left;
if (!xlocals) if (!xlocals)
@ -418,7 +418,7 @@ Value AExpression::OpSetMultiply(const AExpression *expr, const Dictionary::Ptr&
Value result = left * expr->EvaluateOperand2(xlocals, sdhint); Value result = left * expr->EvaluateOperand2(xlocals, sdhint);
if (exp_right->m_Operator == &AExpression::OpDict) { if (exp_right->m_Operator == &Expression::OpDict) {
Dictionary::Ptr dict = result; Dictionary::Ptr dict = result;
dict->Remove("__parent"); dict->Remove("__parent");
} }
@ -431,14 +431,14 @@ Value AExpression::OpSetMultiply(const AExpression *expr, const Dictionary::Ptr&
return result; return result;
} }
Value AExpression::OpSetDivide(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpSetDivide(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
Value index = expr->EvaluateOperand1(locals); Value index = expr->EvaluateOperand1(locals);
Value left = locals->Get(index); Value left = locals->Get(index);
AExpression::Ptr exp_right = expr->m_Operand2; Expression::Ptr exp_right = expr->m_Operand2;
Dictionary::Ptr xlocals = locals; Dictionary::Ptr xlocals = locals;
if (exp_right->m_Operator == &AExpression::OpDict) { if (exp_right->m_Operator == &Expression::OpDict) {
xlocals = left; xlocals = left;
if (!xlocals) if (!xlocals)
@ -453,7 +453,7 @@ Value AExpression::OpSetDivide(const AExpression *expr, const Dictionary::Ptr& l
Value result = left / expr->EvaluateOperand2(xlocals, sdhint); Value result = left / expr->EvaluateOperand2(xlocals, sdhint);
if (exp_right->m_Operator == &AExpression::OpDict) { if (exp_right->m_Operator == &Expression::OpDict) {
Dictionary::Ptr dict = result; Dictionary::Ptr dict = result;
dict->Remove("__parent"); dict->Remove("__parent");
} }
@ -466,7 +466,7 @@ Value AExpression::OpSetDivide(const AExpression *expr, const Dictionary::Ptr& l
return result; return result;
} }
Value AExpression::OpIndexer(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpIndexer(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
Value value = expr->EvaluateOperand1(locals); Value value = expr->EvaluateOperand1(locals);
Value index = expr->EvaluateOperand2(locals); Value index = expr->EvaluateOperand2(locals);
@ -497,7 +497,7 @@ Value AExpression::OpIndexer(const AExpression *expr, const Dictionary::Ptr& loc
} }
} }
Value AExpression::OpImport(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpImport(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
Value type = expr->EvaluateOperand1(locals); Value type = expr->EvaluateOperand1(locals);
Value name = expr->EvaluateOperand2(locals); Value name = expr->EvaluateOperand2(locals);
@ -512,7 +512,7 @@ Value AExpression::OpImport(const AExpression *expr, const Dictionary::Ptr& loca
return Empty; return Empty;
} }
Value AExpression::FunctionWrapper(const std::vector<Value>& arguments, const Array::Ptr& funcargs, const AExpression::Ptr& expr, const Dictionary::Ptr& scope) Value Expression::FunctionWrapper(const std::vector<Value>& arguments, const Array::Ptr& funcargs, const Expression::Ptr& expr, const Dictionary::Ptr& scope)
{ {
if (arguments.size() < funcargs->GetLength()) if (arguments.size() < funcargs->GetLength())
BOOST_THROW_EXCEPTION(ConfigError("Too few arguments for function")); BOOST_THROW_EXCEPTION(ConfigError("Too few arguments for function"));
@ -527,14 +527,14 @@ Value AExpression::FunctionWrapper(const std::vector<Value>& arguments, const Ar
return locals->Get("__result"); return locals->Get("__result");
} }
Value AExpression::OpFunction(const AExpression* expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpFunction(const Expression* expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
Array::Ptr left = expr->m_Operand1; Array::Ptr left = expr->m_Operand1;
AExpression::Ptr aexpr = left->Get(1); Expression::Ptr aexpr = left->Get(1);
String name = left->Get(0); String name = left->Get(0);
Array::Ptr funcargs = expr->m_Operand2; Array::Ptr funcargs = expr->m_Operand2;
ScriptFunction::Ptr func = make_shared<ScriptFunction>(boost::bind(&AExpression::FunctionWrapper, _1, funcargs, aexpr, locals)); ScriptFunction::Ptr func = make_shared<ScriptFunction>(boost::bind(&Expression::FunctionWrapper, _1, funcargs, aexpr, locals));
if (!name.IsEmpty()) if (!name.IsEmpty())
ScriptFunction::Register(name, func); ScriptFunction::Register(name, func);
@ -542,14 +542,14 @@ Value AExpression::OpFunction(const AExpression* expr, const Dictionary::Ptr& lo
return func; return func;
} }
Value AExpression::OpApply(const AExpression* expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpApply(const Expression* expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
Array::Ptr left = expr->m_Operand1; Array::Ptr left = expr->m_Operand1;
AExpression::Ptr exprl = expr->m_Operand2; Expression::Ptr exprl = expr->m_Operand2;
String type = left->Get(0); String type = left->Get(0);
String target = left->Get(1); String target = left->Get(1);
AExpression::Ptr aname = left->Get(2); Expression::Ptr aname = left->Get(2);
AExpression::Ptr filter = left->Get(3); Expression::Ptr filter = left->Get(3);
String name = aname->Evaluate(locals, dhint); String name = aname->Evaluate(locals, dhint);
@ -558,14 +558,14 @@ Value AExpression::OpApply(const AExpression* expr, const Dictionary::Ptr& local
return Empty; return Empty;
} }
Value AExpression::OpObject(const AExpression* expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpObject(const Expression* expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
Array::Ptr left = expr->m_Operand1; Array::Ptr left = expr->m_Operand1;
AExpression::Ptr exprl = expr->m_Operand2; Expression::Ptr exprl = expr->m_Operand2;
bool abstract = left->Get(0); bool abstract = left->Get(0);
String type = left->Get(1); String type = left->Get(1);
AExpression::Ptr aname = left->Get(2); Expression::Ptr aname = left->Get(2);
AExpression::Ptr filter = left->Get(3); Expression::Ptr filter = left->Get(3);
String zone = left->Get(4); String zone = left->Get(4);
String name = aname->Evaluate(locals, dhint); String name = aname->Evaluate(locals, dhint);
@ -612,12 +612,12 @@ Value AExpression::OpObject(const AExpression* expr, const Dictionary::Ptr& loca
return Empty; return Empty;
} }
Value AExpression::OpFor(const AExpression* expr, const Dictionary::Ptr& locals, DebugHint *dhint) Value Expression::OpFor(const Expression* expr, const Dictionary::Ptr& locals, DebugHint *dhint)
{ {
Array::Ptr left = expr->m_Operand1; Array::Ptr left = expr->m_Operand1;
String varname = left->Get(0); String varname = left->Get(0);
AExpression::Ptr aexpr = left->Get(1); Expression::Ptr aexpr = left->Get(1);
AExpression::Ptr ascope = expr->m_Operand2; Expression::Ptr ascope = expr->m_Operand2;
Array::Ptr arr = aexpr->Evaluate(locals, dhint); Array::Ptr arr = aexpr->Evaluate(locals, dhint);

90
lib/config/aexpression.hpp → lib/config/expression.hpp
View File

@ -17,8 +17,8 @@
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. * * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/ ******************************************************************************/
#ifndef AEXPRESSION_H #ifndef EXPRESSION_H
#define AEXPRESSION_H #define EXPRESSION_H
#include "config/i2-config.hpp" #include "config/i2-config.hpp"
#include "base/debuginfo.hpp" #include "base/debuginfo.hpp"
@ -49,15 +49,15 @@ struct DebugHint
/** /**
* @ingroup config * @ingroup config
*/ */
class I2_CONFIG_API AExpression : public Object class I2_CONFIG_API Expression : public Object
{ {
public: public:
DECLARE_PTR_TYPEDEFS(AExpression); DECLARE_PTR_TYPEDEFS(Expression);
typedef Value (*OpCallback)(const AExpression *, const Dictionary::Ptr&, DebugHint *dhint); typedef Value (*OpCallback)(const Expression *, const Dictionary::Ptr&, DebugHint *dhint);
AExpression(OpCallback op, const Value& operand1, const DebugInfo& di); Expression(OpCallback op, const Value& operand1, const DebugInfo& di);
AExpression(OpCallback op, const Value& operand1, const Value& operand2, const DebugInfo& di); Expression(OpCallback op, const Value& operand1, const Value& operand2, const DebugInfo& di);
Value Evaluate(const Dictionary::Ptr& locals, DebugHint *dhint = NULL) const; Value Evaluate(const Dictionary::Ptr& locals, DebugHint *dhint = NULL) const;
@ -65,42 +65,42 @@ public:
void Dump(std::ostream& stream, int indent = 0) const; void Dump(std::ostream& stream, int indent = 0) const;
static Value OpLiteral(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpLiteral(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpVariable(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpVariable(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpNegate(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpNegate(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpLogicalNegate(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpLogicalNegate(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpAdd(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpAdd(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpSubtract(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpSubtract(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpMultiply(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpMultiply(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpDivide(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpDivide(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpBinaryAnd(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpBinaryAnd(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpBinaryOr(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpBinaryOr(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpShiftLeft(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpShiftLeft(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpShiftRight(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpShiftRight(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpEqual(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpEqual(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpNotEqual(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpNotEqual(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpLessThan(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpLessThan(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpGreaterThan(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpGreaterThan(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpLessThanOrEqual(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpLessThanOrEqual(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpGreaterThanOrEqual(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpGreaterThanOrEqual(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpIn(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpIn(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpNotIn(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpNotIn(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpLogicalAnd(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpLogicalAnd(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpLogicalOr(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpLogicalOr(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpFunctionCall(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpFunctionCall(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpArray(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpArray(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpDict(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpDict(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpSet(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpSet(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpSetPlus(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpSetPlus(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpSetMinus(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpSetMinus(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpSetMultiply(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpSetMultiply(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpSetDivide(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpSetDivide(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpIndexer(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpIndexer(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpImport(const AExpression *expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpImport(const Expression *expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpFunction(const AExpression* expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpFunction(const Expression* expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpApply(const AExpression* expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpApply(const Expression* expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpObject(const AExpression* expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpObject(const Expression* expr, const Dictionary::Ptr& locals, DebugHint *dhint);
static Value OpFor(const AExpression* expr, const Dictionary::Ptr& locals, DebugHint *dhint); static Value OpFor(const Expression* expr, const Dictionary::Ptr& locals, DebugHint *dhint);
private: private:
OpCallback m_Operator; OpCallback m_Operator;
@ -114,9 +114,9 @@ private:
static void DumpOperand(std::ostream& stream, const Value& operand, int indent); static void DumpOperand(std::ostream& stream, const Value& operand, int indent);
static Value FunctionWrapper(const std::vector<Value>& arguments, const Array::Ptr& funcargs, static Value FunctionWrapper(const std::vector<Value>& arguments, const Array::Ptr& funcargs,
const AExpression::Ptr& expr, const Dictionary::Ptr& scope); const Expression::Ptr& expr, const Dictionary::Ptr& scope);
}; };
} }
#endif /* TYPERULE_H */ #endif /* EXPRESSION_H */

10
lib/config/objectrule.cpp
View File

@ -26,8 +26,8 @@ using namespace icinga;
ObjectRule::RuleMap ObjectRule::m_Rules; ObjectRule::RuleMap ObjectRule::m_Rules;
ObjectRule::CallbackMap ObjectRule::m_Callbacks; ObjectRule::CallbackMap ObjectRule::m_Callbacks;
ObjectRule::ObjectRule(const String& name, const AExpression::Ptr& expression, ObjectRule::ObjectRule(const String& name, const Expression::Ptr& expression,
const AExpression::Ptr& filter, const DebugInfo& di, const Dictionary::Ptr& scope) const Expression::Ptr& filter, const DebugInfo& di, const Dictionary::Ptr& scope)
: m_Name(name), m_Expression(expression), m_Filter(filter), m_DebugInfo(di), m_Scope(scope) : m_Name(name), m_Expression(expression), m_Filter(filter), m_DebugInfo(di), m_Scope(scope)
{ } { }
@ -36,12 +36,12 @@ String ObjectRule::GetName(void) const
return m_Name; return m_Name;
} }
AExpression::Ptr ObjectRule::GetExpression(void) const Expression::Ptr ObjectRule::GetExpression(void) const
{ {
return m_Expression; return m_Expression;
} }
AExpression::Ptr ObjectRule::GetFilter(void) const Expression::Ptr ObjectRule::GetFilter(void) const
{ {
return m_Filter; return m_Filter;
} }
@ -57,7 +57,7 @@ Dictionary::Ptr ObjectRule::GetScope(void) const
} }
void ObjectRule::AddRule(const String& sourceType, const String& name, void ObjectRule::AddRule(const String& sourceType, const String& name,
const AExpression::Ptr& expression, const AExpression::Ptr& filter, const Expression::Ptr& expression, const Expression::Ptr& filter,
const DebugInfo& di, const Dictionary::Ptr& scope) const DebugInfo& di, const Dictionary::Ptr& scope)
{ {
m_Rules[sourceType].push_back(ObjectRule(name, expression, filter, di, scope)); m_Rules[sourceType].push_back(ObjectRule(name, expression, filter, di, scope));

18
lib/config/objectrule.hpp
View File

@ -21,7 +21,7 @@
#define OBJECTRULE_H #define OBJECTRULE_H
#include "config/i2-config.hpp" #include "config/i2-config.hpp"
#include "config/aexpression.hpp" #include "config/expression.hpp"
#include "base/debuginfo.hpp" #include "base/debuginfo.hpp"
#include "base/dynamictype.hpp" #include "base/dynamictype.hpp"
@ -39,15 +39,15 @@ public:
typedef std::map<String, std::vector<ObjectRule> > RuleMap; typedef std::map<String, std::vector<ObjectRule> > RuleMap;
String GetName(void) const; String GetName(void) const;
AExpression::Ptr GetExpression(void) const; Expression::Ptr GetExpression(void) const;
AExpression::Ptr GetFilter(void) const; Expression::Ptr GetFilter(void) const;
DebugInfo GetDebugInfo(void) const; DebugInfo GetDebugInfo(void) const;
Dictionary::Ptr GetScope(void) const; Dictionary::Ptr GetScope(void) const;
bool EvaluateFilter(const Dictionary::Ptr& scope) const; bool EvaluateFilter(const Dictionary::Ptr& scope) const;
static void AddRule(const String& sourceType, const String& name, const AExpression::Ptr& expression, static void AddRule(const String& sourceType, const String& name, const Expression::Ptr& expression,
const AExpression::Ptr& filter, const DebugInfo& di, const Dictionary::Ptr& scope); const Expression::Ptr& filter, const DebugInfo& di, const Dictionary::Ptr& scope);
static void EvaluateRules(bool clear); static void EvaluateRules(bool clear);
static void RegisterType(const String& sourceType, const ObjectRule::Callback& callback); static void RegisterType(const String& sourceType, const ObjectRule::Callback& callback);
@ -55,16 +55,16 @@ public:
private: private:
String m_Name; String m_Name;
AExpression::Ptr m_Expression; Expression::Ptr m_Expression;
AExpression::Ptr m_Filter; Expression::Ptr m_Filter;
DebugInfo m_DebugInfo; DebugInfo m_DebugInfo;
Dictionary::Ptr m_Scope; Dictionary::Ptr m_Scope;
static CallbackMap m_Callbacks; static CallbackMap m_Callbacks;
static RuleMap m_Rules; static RuleMap m_Rules;
ObjectRule(const String& name, const AExpression::Ptr& expression, ObjectRule(const String& name, const Expression::Ptr& expression,
const AExpression::Ptr& filter, const DebugInfo& di, const Dictionary::Ptr& scope); const Expression::Ptr& filter, const DebugInfo& di, const Dictionary::Ptr& scope);
}; };
} }

24
lib/icinga/dependency-apply.cpp
View File

@ -71,29 +71,29 @@ bool Dependency::EvaluateApplyRuleOne(const Checkable::Ptr& checkable, const App
builder->SetName(rule.GetName()); builder->SetName(rule.GetName());
builder->SetScope(rule.GetScope()); builder->SetScope(rule.GetScope());
builder->AddExpression(make_shared<AExpression>(&AExpression::OpSet, builder->AddExpression(make_shared<Expression>(&Expression::OpSet,
make_shared<AExpression>(&AExpression::OpLiteral, "parent_host_name", di), make_shared<Expression>(&Expression::OpLiteral, "parent_host_name", di),
make_shared<AExpression>(&AExpression::OpLiteral, host->GetName(), di), make_shared<Expression>(&Expression::OpLiteral, host->GetName(), di),
di)); di));
builder->AddExpression(make_shared<AExpression>(&AExpression::OpSet, builder->AddExpression(make_shared<Expression>(&Expression::OpSet,
make_shared<AExpression>(&AExpression::OpLiteral, "child_host_name", di), make_shared<Expression>(&Expression::OpLiteral, "child_host_name", di),
make_shared<AExpression>(&AExpression::OpLiteral, host->GetName(), di), make_shared<Expression>(&Expression::OpLiteral, host->GetName(), di),
di)); di));
if (service) { if (service) {
builder->AddExpression(make_shared<AExpression>(&AExpression::OpSet, builder->AddExpression(make_shared<Expression>(&Expression::OpSet,
make_shared<AExpression>(&AExpression::OpLiteral, "child_service_name", di), make_shared<Expression>(&Expression::OpLiteral, "child_service_name", di),
make_shared<AExpression>(&AExpression::OpLiteral, service->GetShortName(), di), make_shared<Expression>(&Expression::OpLiteral, service->GetShortName(), di),
di)); di));
} }
String zone = checkable->GetZone(); String zone = checkable->GetZone();
if (!zone.IsEmpty()) { if (!zone.IsEmpty()) {
builder->AddExpression(make_shared<AExpression>(&AExpression::OpSet, builder->AddExpression(make_shared<Expression>(&Expression::OpSet,
make_shared<AExpression>(&AExpression::OpLiteral, "zone", di), make_shared<Expression>(&Expression::OpLiteral, "zone", di),
make_shared<AExpression>(&AExpression::OpLiteral, zone, di), make_shared<Expression>(&Expression::OpLiteral, zone, di),
di)); di));
} }

18
lib/icinga/notification-apply.cpp
View File

@ -71,24 +71,24 @@ bool Notification::EvaluateApplyRuleOne(const Checkable::Ptr& checkable, const A
builder->SetName(rule.GetName()); builder->SetName(rule.GetName());
builder->SetScope(rule.GetScope()); builder->SetScope(rule.GetScope());
builder->AddExpression(make_shared<AExpression>(&AExpression::OpSet, builder->AddExpression(make_shared<Expression>(&Expression::OpSet,
make_shared<AExpression>(&AExpression::OpLiteral, "host_name", di), make_shared<Expression>(&Expression::OpLiteral, "host_name", di),
make_shared<AExpression>(&AExpression::OpLiteral, host->GetName(), di), make_shared<Expression>(&Expression::OpLiteral, host->GetName(), di),
di)); di));
if (service) { if (service) {
builder->AddExpression(make_shared<AExpression>(&AExpression::OpSet, builder->AddExpression(make_shared<Expression>(&Expression::OpSet,
make_shared<AExpression>(&AExpression::OpLiteral, "service_name", di), make_shared<Expression>(&Expression::OpLiteral, "service_name", di),
make_shared<AExpression>(&AExpression::OpLiteral, service->GetShortName(), di), make_shared<Expression>(&Expression::OpLiteral, service->GetShortName(), di),
di)); di));
} }
String zone = checkable->GetZone(); String zone = checkable->GetZone();
if (!zone.IsEmpty()) { if (!zone.IsEmpty()) {
builder->AddExpression(make_shared<AExpression>(&AExpression::OpSet, builder->AddExpression(make_shared<Expression>(&Expression::OpSet,
make_shared<AExpression>(&AExpression::OpLiteral, "zone", di), make_shared<Expression>(&Expression::OpLiteral, "zone", di),
make_shared<AExpression>(&AExpression::OpLiteral, zone, di), make_shared<Expression>(&Expression::OpLiteral, zone, di),
di)); di));
} }

18
lib/icinga/scheduleddowntime-apply.cpp
View File

@ -70,24 +70,24 @@ bool ScheduledDowntime::EvaluateApplyRule(const Checkable::Ptr& checkable, const
builder->SetName(rule.GetName()); builder->SetName(rule.GetName());
builder->SetScope(rule.GetScope()); builder->SetScope(rule.GetScope());
builder->AddExpression(make_shared<AExpression>(&AExpression::OpSet, builder->AddExpression(make_shared<Expression>(&Expression::OpSet,
make_shared<AExpression>(&AExpression::OpLiteral, "host_name", di), make_shared<Expression>(&Expression::OpLiteral, "host_name", di),
make_shared<AExpression>(&AExpression::OpLiteral, host->GetName(), di), make_shared<Expression>(&Expression::OpLiteral, host->GetName(), di),
di)); di));
if (service) { if (service) {
builder->AddExpression(make_shared<AExpression>(&AExpression::OpSet, builder->AddExpression(make_shared<Expression>(&Expression::OpSet,
make_shared<AExpression>(&AExpression::OpLiteral, "service_name", di), make_shared<Expression>(&Expression::OpLiteral, "service_name", di),
make_shared<AExpression>(&AExpression::OpLiteral, service->GetShortName(), di), make_shared<Expression>(&Expression::OpLiteral, service->GetShortName(), di),
di)); di));
} }
String zone = checkable->GetZone(); String zone = checkable->GetZone();
if (!zone.IsEmpty()) { if (!zone.IsEmpty()) {
builder->AddExpression(make_shared<AExpression>(&AExpression::OpSet, builder->AddExpression(make_shared<Expression>(&Expression::OpSet,
make_shared<AExpression>(&AExpression::OpLiteral, "zone", di), make_shared<Expression>(&Expression::OpLiteral, "zone", di),
make_shared<AExpression>(&AExpression::OpLiteral, zone, di), make_shared<Expression>(&Expression::OpLiteral, zone, di),
di)); di));
} }

18
lib/icinga/service-apply.cpp
View File

@ -63,22 +63,22 @@ bool Service::EvaluateApplyRuleOne(const Host::Ptr& host, const ApplyRule& rule)
builder->SetName(rule.GetName()); builder->SetName(rule.GetName());
builder->SetScope(rule.GetScope()); builder->SetScope(rule.GetScope());
builder->AddExpression(make_shared<AExpression>(&AExpression::OpSet, builder->AddExpression(make_shared<Expression>(&Expression::OpSet,
make_shared<AExpression>(&AExpression::OpLiteral, "host_name", di), make_shared<Expression>(&Expression::OpLiteral, "host_name", di),
make_shared<AExpression>(&AExpression::OpLiteral, host->GetName(), di), make_shared<Expression>(&Expression::OpLiteral, host->GetName(), di),
di)); di));
builder->AddExpression(make_shared<AExpression>(&AExpression::OpSet, builder->AddExpression(make_shared<Expression>(&Expression::OpSet,
make_shared<AExpression>(&AExpression::OpLiteral, "name", di), make_shared<Expression>(&Expression::OpLiteral, "name", di),
make_shared<AExpression>(&AExpression::OpLiteral, rule.GetName(), di), make_shared<Expression>(&Expression::OpLiteral, rule.GetName(), di),
di)); di));
String zone = host->GetZone(); String zone = host->GetZone();
if (!zone.IsEmpty()) { if (!zone.IsEmpty()) {
builder->AddExpression(make_shared<AExpression>(&AExpression::OpSet, builder->AddExpression(make_shared<Expression>(&Expression::OpSet,
make_shared<AExpression>(&AExpression::OpLiteral, "zone", di), make_shared<Expression>(&Expression::OpLiteral, "zone", di),
make_shared<AExpression>(&AExpression::OpLiteral, zone, di), make_shared<Expression>(&Expression::OpLiteral, zone, di),
di)); di));
} }