granicus.if.org Git - icinga2/blob - lib/config/config_parser.yy

   1 %{
   2  #define YYDEBUG 1
   3
   4 /******************************************************************************
   5  * Icinga 2                                                                   *
   6  * Copyright (C) 2012-2014 Icinga Development Team (http://www.icinga.org)    *
   7  *                                                                            *
   8  * This program is free software; you can redistribute it and/or              *
   9  * modify it under the terms of the GNU General Public License                *
  10  * as published by the Free Software Foundation; either version 2             *
  11  * of the License, or (at your option) any later version.                     *
  12  *                                                                            *
  13  * This program is distributed in the hope that it will be useful,            *
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of             *
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *
  16  * GNU General Public License for more details.                               *
  17  *                                                                            *
  18  * You should have received a copy of the GNU General Public License          *
  19  * along with this program; if not, write to the Free Software Foundation     *
  20  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.             *
  21  ******************************************************************************/
  22
  23 #include "i2-config.h"
  24 #include "config/configitembuilder.h"
  25 #include "config/configcompiler.h"
  26 #include "config/configcompilercontext.h"
  27 #include "config/configerror.h"
  28 #include "config/typerule.h"
  29 #include "config/typerulelist.h"
  30 #include "config/aexpression.h"
  31 #include "config/applyrule.h"
  32 #include "base/value.h"
  33 #include "base/utility.h"
  34 #include "base/array.h"
  35 #include "base/scriptvariable.h"
  36 #include "base/exception.h"
  37 #include "base/dynamictype.h"
  38 #include <sstream>
  39 #include <stack>
  40 #include <boost/foreach.hpp>
  41
  42 #define YYLTYPE icinga::DebugInfo
  43 #define YYERROR_VERBOSE
  44
  45 #define YYLLOC_DEFAULT(Current, Rhs, N)                                 \
  46 do {                                                                    \
  47         if (N) {                                                        \
  48                 (Current).Path = YYRHSLOC(Rhs, 1).Path;                 \
  49                 (Current).FirstLine = YYRHSLOC(Rhs, 1).FirstLine;       \
  50                 (Current).FirstColumn = YYRHSLOC(Rhs, 1).FirstColumn;   \
  51                 (Current).LastLine = YYRHSLOC(Rhs, N).LastLine;         \
  52                 (Current).LastColumn = YYRHSLOC(Rhs, N).LastColumn;     \
  53         } else {                                                        \
  54                 (Current).Path = YYRHSLOC(Rhs, 0).Path;                 \
  55                 (Current).FirstLine = (Current).LastLine =              \
  56                 YYRHSLOC(Rhs, 0).LastLine;                              \
  57                 (Current).FirstColumn = (Current).LastColumn =          \
  58                 YYRHSLOC(Rhs, 0).LastColumn;                            \
  59         }                                                               \
  60 } while (0)
  61
  62 #define YY_LOCATION_PRINT(file, loc)                    \
  63 do {                                                    \
  64        std::ostringstream msgbuf;                       \
  65        msgbuf << loc;                                   \
  66        std::string str = msgbuf.str();                  \
  67        fputs(str.c_str(), file);                        \
  68 } while (0)
  69
  70 using namespace icinga;
  71
  72 static void MakeRBinaryOp(Value** result, AExpression::OpCallback& op, Value *left, Value *right, DebugInfo& diLeft, DebugInfo& diRight)
  73 {
  74         *result = new Value(make_shared<AExpression>(op, static_cast<AExpression::Ptr>(*left), static_cast<AExpression::Ptr>(*right), DebugInfoRange(diLeft, diRight)));
  75         delete left;
  76         delete right;
  77 }
  78
  79 %}
  80
  81 %pure-parser
  82
  83 %locations
  84 %defines
  85 %error-verbose
  86
  87 %parse-param { ConfigCompiler *context }
  88 %lex-param { void *scanner }
  89
  90 %union {
  91         char *text;
  92         double num;
  93         icinga::Value *variant;
  94         icinga::AExpression::OpCallback op;
  95         icinga::TypeSpecifier type;
  96         std::vector<String> *slist;
  97         Array *array;
  98 }
  99
 100 %token <text> T_STRING
 101 %token <text> T_STRING_ANGLE
 102 %token <num> T_NUMBER
 103 %token T_NULL
 104 %token <text> T_IDENTIFIER
 105
 106 %token <op> T_SET "= (T_SET)"
 107 %token <op> T_SET_PLUS "+= (T_SET_PLUS)"
 108 %token <op> T_SET_MINUS "-= (T_SET_MINUS)"
 109 %token <op> T_SET_MULTIPLY "*= (T_SET_MULTIPLY)"
 110 %token <op> T_SET_DIVIDE "/= (T_SET_DIVIDE)"
 111
 112 %token <op> T_SHIFT_LEFT "<< (T_SHIFT_LEFT)"
 113 %token <op> T_SHIFT_RIGHT ">> (T_SHIFT_RIGHT)"
 114 %token <op> T_EQUAL "== (T_EQUAL)"
 115 %token <op> T_NOT_EQUAL "!= (T_NOT_EQUAL)"
 116 %token <op> T_IN "in (T_IN)"
 117 %token <op> T_NOT_IN "!in (T_NOT_IN)"
 118 %token <op> T_LOGICAL_AND "&& (T_LOGICAL_AND)"
 119 %token <op> T_LOGICAL_OR "|| (T_LOGICAL_OR)"
 120 %token <op> T_LESS_THAN_OR_EQUAL "<= (T_LESS_THAN_OR_EQUAL)"
 121 %token <op> T_GREATER_THAN_OR_EQUAL ">= (T_GREATER_THAN_OR_EQUAL)"
 122 %token <op> T_PLUS "+ (T_PLUS)"
 123 %token <op> T_MINUS "- (T_MINUS)"
 124 %token <op> T_MULTIPLY "* (T_MULTIPLY)"
 125 %token <op> T_DIVIDE_OP "/ (T_DIVIDE_OP)"
 126 %token <op> T_BINARY_AND "& (T_BINARY_AND)"
 127 %token <op> T_BINARY_OR "| (T_BINARY_OR)"
 128 %token <op> T_LESS_THAN "< (T_LESS_THAN)"
 129 %token <op> T_GREATER_THAN "> (T_GREATER_THAN)"
 130
 131 %token T_CONST "const (T_CONST)"
 132 %token <type> T_TYPE_DICTIONARY "dictionary (T_TYPE_DICTIONARY)"
 133 %token <type> T_TYPE_ARRAY "array (T_TYPE_ARRAY)"
 134 %token <type> T_TYPE_NUMBER "number (T_TYPE_NUMBER)"
 135 %token <type> T_TYPE_STRING "string (T_TYPE_STRING)"
 136 %token <type> T_TYPE_SCALAR "scalar (T_TYPE_SCALAR)"
 137 %token <type> T_TYPE_ANY "any (T_TYPE_ANY)"
 138 %token <type> T_TYPE_NAME "name (T_TYPE_NAME)"
 139 %token T_VALIDATOR "%validator (T_VALIDATOR)"
 140 %token T_REQUIRE "%require (T_REQUIRE)"
 141 %token T_ATTRIBUTE "%attribute (T_ATTRIBUTE)"
 142 %token T_TYPE "type (T_TYPE)"
 143 %token T_OBJECT "object (T_OBJECT)"
 144 %token T_TEMPLATE "template (T_TEMPLATE)"
 145 %token T_INCLUDE "include (T_INCLUDE)"
 146 %token T_INCLUDE_RECURSIVE "include_recursive (T_INCLUDE_RECURSIVE)"
 147 %token T_LIBRARY "library (T_LIBRARY)"
 148 %token T_INHERITS "inherits (T_INHERITS)"
 149 %token T_PARTIAL "partial (T_PARTIAL)"
 150 %token T_APPLY "apply (T_APPLY)"
 151 %token T_WHERE "where (T_WHERE)"
 152 %token T_IMPORT "import (T_IMPORT)"
 153 %token T_ASSIGN "assign (T_ASSIGN)"
 154 %token T_IGNORE "ignore (T_IGNORE)"
 155 %token T_FUNCTION "function (T_FUNCTION)"
 156 %token T_LAMBDA "lambda (T_LAMBDA)"
 157
 158 %type <text> identifier
 159 %type <array> rterm_items
 160 %type <array> rterm_items_inner
 161 %type <array> identifier_items
 162 %type <array> identifier_items_inner
 163 %type <array> lterm_items
 164 %type <array> lterm_items_inner
 165 %type <variant> typerulelist
 166 %type <op> lbinary_op
 167 %type <type> type
 168 %type <num> partial_specifier
 169 %type <variant> rterm
 170 %type <variant> rterm_scope
 171 %type <variant> lterm
 172 %type <variant> object
 173 %type <variant> apply
 174
 175 %left T_LOGICAL_OR
 176 %left T_LOGICAL_AND
 177 %left T_BINARY_OR
 178 %left T_BINARY_AND
 179 %left T_IN
 180 %left T_NOT_IN
 181 %left T_EQUAL T_NOT_EQUAL
 182 %left T_LESS_THAN T_LESS_THAN_OR_EQUAL T_GREATER_THAN T_GREATER_THAN_OR_EQUAL
 183 %left T_SHIFT_LEFT T_SHIFT_RIGHT
 184 %left T_PLUS T_MINUS
 185 %left T_MULTIPLY T_DIVIDE_OP
 186 %right '!' '~'
 187 %left '.' '(' '['
 188 %{
 189
 190 int yylex(YYSTYPE *lvalp, YYLTYPE *llocp, void *scanner);
 191
 192 void yyerror(YYLTYPE *locp, ConfigCompiler *, const char *err)
 193 {
 194         std::ostringstream message;
 195         message << *locp << ": " << err;
 196         ConfigCompilerContext::GetInstance()->AddMessage(true, message.str(), *locp);
 197 }
 198
 199 int yyparse(ConfigCompiler *context);
 200
 201 static bool m_Abstract;
 202
 203 static std::stack<TypeRuleList::Ptr> m_RuleLists;
 204 static ConfigType::Ptr m_Type;
 205
 206 static Dictionary::Ptr m_ModuleScope;
 207
 208 static bool m_Apply;
 209 static AExpression::Ptr m_Assign;
 210 static AExpression::Ptr m_Ignore;
 211
 212 void ConfigCompiler::Compile(void)
 213 {
 214         m_ModuleScope = make_shared<Dictionary>();
 215
 216         try {
 217                 yyparse(this);
 218         } catch (const ConfigError& ex) {
 219                 const DebugInfo *di = boost::get_error_info<errinfo_debuginfo>(ex);
 220                 ConfigCompilerContext::GetInstance()->AddMessage(true, ex.what(), di ? *di : DebugInfo());
 221         } catch (const std::exception& ex) {
 222                 ConfigCompilerContext::GetInstance()->AddMessage(true, DiagnosticInformation(ex));
 223         }
 224 }
 225
 226 #define scanner (context->GetScanner())
 227
 228 %}
 229
 230 %%
 231 statements: /* empty */
 232         | statements statement
 233         ;
 234
 235 statement: type | include | include_recursive | library | constant
 236         { }
 237         | lterm
 238         {
 239                 AExpression::Ptr aexpr = *$1;
 240                 aexpr->Evaluate(m_ModuleScope);
 241                 delete $1;
 242         }
 243         ;
 244
 245 include: T_INCLUDE rterm
 246         {
 247                 AExpression::Ptr aexpr = static_cast<AExpression::Ptr>(*$2);
 248                 delete $2;
 249
 250                 context->HandleInclude(aexpr->Evaluate(m_ModuleScope), false, DebugInfoRange(@1, @2));
 251         }
 252         | T_INCLUDE T_STRING_ANGLE
 253         {
 254                 context->HandleInclude($2, true, DebugInfoRange(@1, @2));
 255                 free($2);
 256         }
 257         ;
 258
 259 include_recursive: T_INCLUDE_RECURSIVE rterm
 260         {
 261                 AExpression::Ptr aexpr = static_cast<AExpression::Ptr>(*$2);
 262                 delete $2;
 263
 264                 context->HandleIncludeRecursive(aexpr->Evaluate(m_ModuleScope), "*.conf", DebugInfoRange(@1, @2));
 265         }
 266         | T_INCLUDE_RECURSIVE rterm rterm
 267         {
 268                 AExpression::Ptr aexpr1 = static_cast<AExpression::Ptr>(*$2);
 269                 delete $2;
 270
 271                 AExpression::Ptr aexpr2 = static_cast<AExpression::Ptr>(*$3);
 272                 delete $3;
 273
 274                 context->HandleIncludeRecursive(aexpr1->Evaluate(m_ModuleScope), aexpr2->Evaluate(m_ModuleScope), DebugInfoRange(@1, @3));
 275         }
 276         ;
 277
 278 library: T_LIBRARY T_STRING
 279         {
 280                 context->HandleLibrary($2);
 281                 free($2);
 282         }
 283         ;
 284
 285 constant: T_CONST identifier T_SET rterm
 286         {
 287                 AExpression::Ptr aexpr = static_cast<AExpression::Ptr>(*$4);
 288                 delete $4;
 289
 290                 ScriptVariable::Ptr sv = ScriptVariable::Set($2, aexpr->Evaluate(m_ModuleScope));
 291                 sv->SetConstant(true);
 292
 293                 free($2);
 294         }
 295         ;
 296
 297 identifier: T_IDENTIFIER
 298         | T_STRING
 299         {
 300                 $$ = $1;
 301         }
 302         ;
 303
 304 type: partial_specifier T_TYPE identifier
 305         {
 306                 String name = String($3);
 307                 free($3);
 308
 309                 m_Type = ConfigType::GetByName(name);
 310
 311                 if (!m_Type) {
 312                         if ($1)
 313                                 BOOST_THROW_EXCEPTION(ConfigError("Partial type definition for unknown type '" + name + "'") << errinfo_debuginfo(DebugInfoRange(@1, @3)));
 314
 315                         m_Type = make_shared<ConfigType>(name, DebugInfoRange(@1, @3));
 316                         m_Type->Register();
 317                 }
 318         }
 319         type_inherits_specifier typerulelist
 320         {
 321                 TypeRuleList::Ptr ruleList = *$6;
 322                 m_Type->GetRuleList()->AddRules(ruleList);
 323                 m_Type->GetRuleList()->AddRequires(ruleList);
 324
 325                 String validator = ruleList->GetValidator();
 326                 if (!validator.IsEmpty())
 327                         m_Type->GetRuleList()->SetValidator(validator);
 328
 329                 delete $6;
 330         }
 331         ;
 332
 333 partial_specifier: /* Empty */
 334         {
 335                 $$ = 0;
 336         }
 337         | T_PARTIAL
 338         {
 339                 $$ = 1;
 340         }
 341         ;
 342
 343 typerulelist: '{'
 344         {
 345                 m_RuleLists.push(make_shared<TypeRuleList>());
 346         }
 347         typerules
 348         '}'
 349         {
 350                 $$ = new Value(m_RuleLists.top());
 351                 m_RuleLists.pop();
 352         }
 353         ;
 354
 355 typerules: typerules_inner
 356         | typerules_inner ','
 357
 358 typerules_inner: /* empty */
 359         | typerule
 360         | typerules_inner ',' typerule
 361         ;
 362
 363 typerule: T_REQUIRE T_STRING
 364         {
 365                 m_RuleLists.top()->AddRequire($2);
 366                 free($2);
 367         }
 368         | T_VALIDATOR T_STRING
 369         {
 370                 m_RuleLists.top()->SetValidator($2);
 371                 free($2);
 372         }
 373         | T_ATTRIBUTE type T_STRING
 374         {
 375                 TypeRule rule($2, String(), $3, TypeRuleList::Ptr(), DebugInfoRange(@1, @3));
 376                 free($3);
 377
 378                 m_RuleLists.top()->AddRule(rule);
 379         }
 380         | T_ATTRIBUTE T_TYPE_NAME '(' identifier ')' T_STRING
 381         {
 382                 TypeRule rule($2, $4, $6, TypeRuleList::Ptr(), DebugInfoRange(@1, @6));
 383                 free($4);
 384                 free($6);
 385
 386                 m_RuleLists.top()->AddRule(rule);
 387         }
 388         | T_ATTRIBUTE type T_STRING typerulelist
 389         {
 390                 TypeRule rule($2, String(), $3, *$4, DebugInfoRange(@1, @4));
 391                 free($3);
 392                 delete $4;
 393                 m_RuleLists.top()->AddRule(rule);
 394         }
 395         ;
 396
 397 type_inherits_specifier: /* empty */
 398         | T_INHERITS identifier
 399         {
 400                 m_Type->SetParent($2);
 401                 free($2);
 402         }
 403         ;
 404
 405 type: T_TYPE_DICTIONARY
 406         | T_TYPE_ARRAY
 407         | T_TYPE_NUMBER
 408         | T_TYPE_STRING
 409         | T_TYPE_SCALAR
 410         | T_TYPE_ANY
 411         | T_TYPE_NAME
 412         {
 413                 $$ = $1;
 414         }
 415         ;
 416
 417 object:
 418         {
 419                 m_Abstract = false;
 420         }
 421         object_declaration identifier rterm rterm_scope
 422         {
 423                 Array::Ptr args = make_shared<Array>();
 424
 425                 args->Add(m_Abstract);
 426
 427                 args->Add($3);
 428                 free($3);
 429
 430                 args->Add(*$4);
 431                 delete $4;
 432
 433                 AExpression::Ptr exprl = *$5;
 434                 delete $5;
 435                 exprl->MakeInline();
 436
 437                 $$ = new Value(make_shared<AExpression>(&AExpression::OpObject, args, exprl, DebugInfoRange(@2, @5)));
 438         }
 439         ;
 440
 441 object_declaration: T_OBJECT
 442         | T_TEMPLATE
 443         {
 444                 m_Abstract = true;
 445         }
 446
 447 identifier_items: identifier_items_inner
 448         {
 449                 $$ = $1;
 450         }
 451         | identifier_items_inner ','
 452         {
 453                 $$ = $1;
 454         }
 455         ;
 456
 457 identifier_items_inner: /* empty */
 458         {
 459                 $$ = new Array();
 460         }
 461         | identifier
 462         {
 463                 $$ = new Array();
 464                 $$->Add($1);
 465                 free($1);
 466         }
 467         | identifier_items_inner ',' identifier
 468         {
 469                 if ($1)
 470                         $$ = $1;
 471                 else
 472                         $$ = new Array();
 473
 474                 $$->Add($3);
 475                 free($3);
 476         }
 477         ;
 478
 479 lbinary_op: T_SET
 480         | T_SET_PLUS
 481         | T_SET_MINUS
 482         | T_SET_MULTIPLY
 483         | T_SET_DIVIDE
 484         {
 485                 $$ = $1;
 486         }
 487         ;
 488
 489 comma_or_semicolon: ',' | ';'
 490         ;
 491
 492 lterm_items: lterm_items_inner
 493         {
 494                 $$ = $1;
 495         }
 496         | lterm_items_inner comma_or_semicolon
 497         {
 498                 $$ = $1;
 499         }
 500
 501 lterm_items_inner: /* empty */
 502         {
 503                 $$ = new Array();
 504         }
 505         | lterm
 506         {
 507                 $$ = new Array();
 508                 $$->Add(*$1);
 509                 delete $1;
 510         }
 511         | lterm_items_inner comma_or_semicolon lterm
 512         {
 513                 if ($1)
 514                         $$ = $1;
 515                 else
 516                         $$ = new Array();
 517
 518                 $$->Add(*$3);
 519                 delete $3;
 520         }
 521         ;
 522
 523 lterm: identifier lbinary_op rterm
 524         {
 525                 AExpression::Ptr aindex = make_shared<AExpression>(&AExpression::OpLiteral, $1, @1);
 526                 free($1);
 527
 528                 AExpression::Ptr aexpr = static_cast<AExpression::Ptr>(*$3);
 529                 $$ = new Value(make_shared<AExpression>($2, aindex, aexpr, DebugInfoRange(@1, @3)));
 530                 delete $3;
 531         }
 532         | identifier '[' rterm ']' lbinary_op rterm
 533         {
 534                 AExpression::Ptr subexpr = make_shared<AExpression>($5, static_cast<AExpression::Ptr>(*$3), static_cast<AExpression::Ptr>(*$6), DebugInfoRange(@1, @6));
 535                 delete $3;
 536                 delete $6;
 537
 538                 Array::Ptr subexprl = make_shared<Array>();
 539                 subexprl->Add(subexpr);
 540
 541                 AExpression::Ptr aindex = make_shared<AExpression>(&AExpression::OpLiteral, $1, @1);
 542                 free($1);
 543
 544                 AExpression::Ptr expr = make_shared<AExpression>(&AExpression::OpDict, subexprl, DebugInfoRange(@1, @6));
 545                 $$ = new Value(make_shared<AExpression>(&AExpression::OpSetPlus, aindex, expr, DebugInfoRange(@1, @6)));
 546         }
 547         | identifier '.' T_IDENTIFIER lbinary_op rterm
 548         {
 549                 AExpression::Ptr aindex = make_shared<AExpression>(&AExpression::OpLiteral, $3, @3);
 550                 AExpression::Ptr subexpr = make_shared<AExpression>($4, aindex, static_cast<AExpression::Ptr>(*$5), DebugInfoRange(@1, @5));
 551                 free($3);
 552                 delete $5;
 553
 554                 Array::Ptr subexprl = make_shared<Array>();
 555                 subexprl->Add(subexpr);
 556
 557                 AExpression::Ptr aindexl = make_shared<AExpression>(&AExpression::OpLiteral, $1, @1);
 558                 free($1);
 559
 560                 AExpression::Ptr expr = make_shared<AExpression>(&AExpression::OpDict, subexprl, DebugInfoRange(@1, @5));
 561                 $$ = new Value(make_shared<AExpression>(&AExpression::OpSetPlus, aindexl, expr, DebugInfoRange(@1, @5)));
 562         }
 563         | T_IMPORT rterm
 564         {
 565                 AExpression::Ptr avar = make_shared<AExpression>(&AExpression::OpVariable, "type", DebugInfoRange(@1, @2));
 566                 AExpression::Ptr aexpr = static_cast<AExpression::Ptr>(*$2);
 567                 delete $2;
 568                 $$ = new Value(make_shared<AExpression>(&AExpression::OpImport, avar, aexpr, DebugInfoRange(@1, @2)));
 569         }
 570         | T_ASSIGN T_WHERE rterm
 571         {
 572                 if (!m_Apply)
 573                         BOOST_THROW_EXCEPTION(ConfigError("'assign' keyword not valid in this context."));
 574
 575                 m_Assign = make_shared<AExpression>(&AExpression::OpLogicalOr, m_Assign, static_cast<AExpression::Ptr>(*$3), DebugInfoRange(@1, @3));
 576                 delete $3;
 577
 578                 $$ = new Value(make_shared<AExpression>(&AExpression::OpLiteral, Empty, DebugInfoRange(@1, @3)));
 579         }
 580         | T_IGNORE T_WHERE rterm
 581         {
 582                 if (!m_Apply)
 583                         BOOST_THROW_EXCEPTION(ConfigError("'ignore' keyword not valid in this context."));
 584
 585                 m_Ignore = make_shared<AExpression>(&AExpression::OpLogicalOr, m_Ignore, static_cast<AExpression::Ptr>(*$3), DebugInfoRange(@1, @3));
 586
 587                 delete $3;
 588
 589                 $$ = new Value(make_shared<AExpression>(&AExpression::OpLiteral, Empty, DebugInfoRange(@1, @3)));
 590         }
 591         | apply
 592         {
 593                 $$ = $1;
 594         }
 595         | object
 596         {
 597                 $$ = $1;
 598         }
 599         | rterm
 600         {
 601                 $$ = $1;
 602         }
 603         ;
 604
 605 rterm_items: rterm_items_inner
 606         {
 607                 $$ = $1;
 608         }
 609         | rterm_items_inner ','
 610         {
 611                 $$ = $1;
 612         }
 613         ;
 614
 615 rterm_items_inner: /* empty */
 616         {
 617                 $$ = new Array();
 618         }
 619         | rterm
 620         {
 621                 $$ = new Array();
 622                 $$->Add(*$1);
 623                 delete $1;
 624         }
 625         | rterm_items_inner ',' rterm
 626         {
 627                 if ($1)
 628                         $$ = $1;
 629                 else
 630                         $$ = new Array();
 631
 632                 $$->Add(*$3);
 633                 delete $3;
 634         }
 635         ;
 636
 637 rterm_scope: '{' lterm_items '}'
 638         {
 639                 $$ = new Value(make_shared<AExpression>(&AExpression::OpDict, Array::Ptr($2), DebugInfoRange(@1, @3)));
 640         }
 641         ;
 642
 643 rterm: T_STRING
 644         {
 645                 $$ = new Value(make_shared<AExpression>(&AExpression::OpLiteral, $1, @1));
 646                 free($1);
 647         }
 648         | T_NUMBER
 649         {
 650                 $$ = new Value(make_shared<AExpression>(&AExpression::OpLiteral, $1, @1));
 651         }
 652         | T_NULL
 653         {
 654                 $$ = new Value(make_shared<AExpression>(&AExpression::OpLiteral, Empty, @1));
 655         }
 656         | rterm '.' T_IDENTIFIER
 657         {
 658                 $$ = new Value(make_shared<AExpression>(&AExpression::OpIndexer, static_cast<AExpression::Ptr>(*$1), make_shared<AExpression>(&AExpression::OpLiteral, $3, @3), DebugInfoRange(@1, @3)));
 659                 delete $1;
 660                 free($3);
 661         }
 662         | rterm '(' rterm_items ')'
 663         {
 664                 Array::Ptr arguments = Array::Ptr($3);
 665                 $$ = new Value(make_shared<AExpression>(&AExpression::OpFunctionCall, static_cast<AExpression::Ptr>(*$1), make_shared<AExpression>(&AExpression::OpLiteral, arguments, @3), DebugInfoRange(@1, @4)));
 666                 free($1);
 667         }
 668         | T_IDENTIFIER
 669         {
 670                 $$ = new Value(make_shared<AExpression>(&AExpression::OpVariable, $1, @1));
 671                 free($1);
 672         }
 673         | '!' rterm
 674         {
 675                 $$ = new Value(make_shared<AExpression>(&AExpression::OpLogicalNegate, static_cast<AExpression::Ptr>(*$2), DebugInfoRange(@1, @2)));
 676                 delete $2;
 677         }
 678         | '~' rterm
 679         {
 680                 $$ = new Value(make_shared<AExpression>(&AExpression::OpNegate, static_cast<AExpression::Ptr>(*$2), DebugInfoRange(@1, @2)));
 681                 delete $2;
 682         }
 683         | rterm '[' rterm ']'
 684         {
 685                 $$ = new Value(make_shared<AExpression>(&AExpression::OpIndexer, static_cast<AExpression::Ptr>(*$1), static_cast<AExpression::Ptr>(*$3), DebugInfoRange(@1, @4)));
 686                 delete $1;
 687                 free($3);
 688         }
 689         | '[' rterm_items ']'
 690         {
 691                 $$ = new Value(make_shared<AExpression>(&AExpression::OpArray, Array::Ptr($2), DebugInfoRange(@1, @3)));
 692         }
 693         | rterm_scope
 694         {
 695                 $$ = $1;
 696         }
 697         | '(' rterm ')'
 698         {
 699                 $$ = $2;
 700         }
 701         | rterm T_LOGICAL_OR rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 702         | rterm T_LOGICAL_AND rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 703         | rterm T_BINARY_OR rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 704         | rterm T_BINARY_AND rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 705         | rterm T_IN rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 706         | rterm T_NOT_IN rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 707         | rterm T_EQUAL rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 708         | rterm T_NOT_EQUAL rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 709         | rterm T_LESS_THAN rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 710         | rterm T_LESS_THAN_OR_EQUAL rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 711         | rterm T_GREATER_THAN rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 712         | rterm T_GREATER_THAN_OR_EQUAL rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 713         | rterm T_SHIFT_LEFT rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 714         | rterm T_SHIFT_RIGHT rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 715         | rterm T_PLUS rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 716         | rterm T_MINUS rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 717         | rterm T_MULTIPLY rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 718         | rterm T_DIVIDE_OP rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 719         | T_FUNCTION identifier '(' identifier_items ')' rterm_scope
 720         {
 721                 Array::Ptr arr = make_shared<Array>();
 722
 723                 arr->Add($2);
 724                 free($2);
 725
 726                 AExpression::Ptr aexpr = *$6;
 727                 delete $6;
 728                 aexpr->MakeInline();
 729                 arr->Add(aexpr);
 730
 731                 $$ = new Value(make_shared<AExpression>(&AExpression::OpFunction, arr, Array::Ptr($4), DebugInfoRange(@1, @6)));
 732         }
 733         | T_FUNCTION '(' identifier_items ')' rterm_scope
 734         {
 735                 Array::Ptr arr = make_shared<Array>();
 736
 737                 arr->Add(Empty);
 738
 739                 AExpression::Ptr aexpr = *$5;
 740                 delete $5;
 741                 aexpr->MakeInline();
 742                 arr->Add(aexpr);
 743
 744                 $$ = new Value(make_shared<AExpression>(&AExpression::OpFunction, arr, Array::Ptr($3), DebugInfoRange(@1, @5)));
 745         }
 746         | T_LAMBDA identifier_items ':' rterm
 747         {
 748                 Array::Ptr arr = make_shared<Array>();
 749
 750                 arr->Add(Empty);
 751
 752                 arr->Add(*$4);
 753                 delete $4;
 754
 755                 $$ = new Value(make_shared<AExpression>(&AExpression::OpFunction, arr, Array::Ptr($2), DebugInfoRange(@1, @4)));
 756         }
 757         ;
 758
 759 apply:
 760         {
 761                 m_Apply = true;
 762                 m_Assign = make_shared<AExpression>(&AExpression::OpLiteral, false, DebugInfo());
 763                 m_Ignore = make_shared<AExpression>(&AExpression::OpLiteral, false, DebugInfo());
 764         }
 765         T_APPLY identifier rterm rterm
 766         {
 767                 m_Apply = false;
 768
 769                 AExpression::Ptr aname = static_cast<AExpression::Ptr>(*$4);
 770                 delete $4;
 771                 String type = $3;
 772                 free($3);
 773
 774                 if (!ApplyRule::IsValidType(type))
 775                         BOOST_THROW_EXCEPTION(ConfigError("'apply' cannot be used with type '" + type + "'") << errinfo_debuginfo(DebugInfoRange(@2, @3)));
 776
 777                 AExpression::Ptr exprl = static_cast<AExpression::Ptr>(*$5);
 778                 delete $5;
 779
 780                 exprl->MakeInline();
 781
 782                 // assign && !ignore
 783                 AExpression::Ptr rex = make_shared<AExpression>(&AExpression::OpLogicalNegate, m_Ignore, DebugInfoRange(@2, @5));
 784                 AExpression::Ptr filter = make_shared<AExpression>(&AExpression::OpLogicalAnd, m_Assign, rex, DebugInfoRange(@2, @5));
 785
 786                 Array::Ptr args = make_shared<Array>();
 787                 args->Add(type);
 788                 args->Add(aname);
 789                 args->Add(filter);
 790
 791                 $$ = new Value(make_shared<AExpression>(&AExpression::OpApply, args, exprl, DebugInfoRange(@2, @5)));
 792
 793                 m_Assign.reset();
 794                 m_Ignore.reset();
 795         }
 796 %%