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 %}
  73
  74 %pure-parser
  75
  76 %locations
  77 %defines
  78 %error-verbose
  79
  80 %parse-param { ConfigCompiler *context }
  81 %lex-param { void *scanner }
  82
  83 %union {
  84         char *text;
  85         double num;
  86         icinga::Value *variant;
  87         icinga::AExpression::OpCallback op;
  88         icinga::TypeSpecifier type;
  89         std::vector<String> *slist;
  90         Array *array;
  91 }
  92
  93 %token <text> T_STRING
  94 %token <text> T_STRING_ANGLE
  95 %token <num> T_NUMBER
  96 %token T_NULL
  97 %token <text> T_IDENTIFIER
  98
  99 %token <op> T_SET "= (T_SET)"
 100 %token <op> T_SET_PLUS "+= (T_SET_PLUS)"
 101 %token <op> T_SET_MINUS "-= (T_SET_MINUS)"
 102 %token <op> T_SET_MULTIPLY "*= (T_SET_MULTIPLY)"
 103 %token <op> T_SET_DIVIDE "/= (T_SET_DIVIDE)"
 104
 105 %token <op> T_SHIFT_LEFT "<< (T_SHIFT_LEFT)"
 106 %token <op> T_SHIFT_RIGHT ">> (T_SHIFT_RIGHT)"
 107 %token <op> T_EQUAL "== (T_EQUAL)"
 108 %token <op> T_NOT_EQUAL "!= (T_NOT_EQUAL)"
 109 %token <op> T_IN "in (T_IN)"
 110 %token <op> T_NOT_IN "!in (T_NOT_IN)"
 111 %token <op> T_LOGICAL_AND "&& (T_LOGICAL_AND)"
 112 %token <op> T_LOGICAL_OR "|| (T_LOGICAL_OR)"
 113 %token <op> T_LESS_THAN_OR_EQUAL "<= (T_LESS_THAN_OR_EQUAL)"
 114 %token <op> T_GREATER_THAN_OR_EQUAL ">= (T_GREATER_THAN_OR_EQUAL)"
 115 %token <op> T_PLUS "+ (T_PLUS)"
 116 %token <op> T_MINUS "- (T_MINUS)"
 117 %token <op> T_MULTIPLY "* (T_MULTIPLY)"
 118 %token <op> T_DIVIDE "/ (T_DIVIDE)"
 119 %token <op> T_BINARY_AND "& (T_BINARY_AND)"
 120 %token <op> T_BINARY_OR "| (T_BINARY_OR)"
 121 %token <op> T_LESS_THAN "< (T_LESS_THAN)"
 122 %token <op> T_GREATER_THAN "> (T_GREATER_THAN)"
 123
 124 %token T_VAR "var (T_VAR)"
 125 %token T_CONST "const (T_CONST)"
 126 %token <type> T_TYPE_DICTIONARY "dictionary (T_TYPE_DICTIONARY)"
 127 %token <type> T_TYPE_ARRAY "array (T_TYPE_ARRAY)"
 128 %token <type> T_TYPE_NUMBER "number (T_TYPE_NUMBER)"
 129 %token <type> T_TYPE_STRING "string (T_TYPE_STRING)"
 130 %token <type> T_TYPE_SCALAR "scalar (T_TYPE_SCALAR)"
 131 %token <type> T_TYPE_ANY "any (T_TYPE_ANY)"
 132 %token <type> T_TYPE_NAME "name (T_TYPE_NAME)"
 133 %token T_VALIDATOR "%validator (T_VALIDATOR)"
 134 %token T_REQUIRE "%require (T_REQUIRE)"
 135 %token T_ATTRIBUTE "%attribute (T_ATTRIBUTE)"
 136 %token T_TYPE "type (T_TYPE)"
 137 %token T_OBJECT "object (T_OBJECT)"
 138 %token T_TEMPLATE "template (T_TEMPLATE)"
 139 %token T_INCLUDE "include (T_INCLUDE)"
 140 %token T_INCLUDE_RECURSIVE "include_recursive (T_INCLUDE_RECURSIVE)"
 141 %token T_LIBRARY "library (T_LIBRARY)"
 142 %token T_INHERITS "inherits (T_INHERITS)"
 143 %token T_PARTIAL "partial (T_PARTIAL)"
 144 %token T_APPLY "apply (T_APPLY)"
 145 %token T_TO "to (T_TO)"
 146 %token T_WHERE "where (T_WHERE)"
 147 %type <text> identifier
 148 %type <array> rterm_items
 149 %type <array> rterm_items_inner
 150 %type <array> lterm_items
 151 %type <array> lterm_items_inner
 152 %type <variant> typerulelist
 153 %type <op> lbinary_op
 154 %type <op> rbinary_op
 155 %type <type> type
 156 %type <num> partial_specifier
 157 %type <slist> object_inherits_list
 158 %type <slist> object_inherits_specifier
 159 %type <variant> rterm
 160 %type <variant> rterm_scope
 161 %type <variant> lterm
 162 %type <num> variable_decl
 163 %left T_LOGICAL_OR
 164 %left T_LOGICAL_AND
 165 %left T_IN
 166 %left T_NOT_IN
 167 %nonassoc T_EQUAL
 168 %nonassoc T_NOT_EQUAL
 169 %left '+' '-'
 170 %left '*' '/'
 171 %left '&'
 172 %left '|'
 173 %right '~'
 174 %right '!'
 175 %{
 176
 177 int yylex(YYSTYPE *lvalp, YYLTYPE *llocp, void *scanner);
 178
 179 void yyerror(YYLTYPE *locp, ConfigCompiler *, const char *err)
 180 {
 181         std::ostringstream message;
 182         message << *locp << ": " << err;
 183         ConfigCompilerContext::GetInstance()->AddMessage(true, message.str(), *locp);
 184 }
 185
 186 int yyparse(ConfigCompiler *context);
 187
 188 static bool m_Abstract;
 189
 190 static std::stack<TypeRuleList::Ptr> m_RuleLists;
 191 static ConfigType::Ptr m_Type;
 192
 193 static Dictionary::Ptr m_ModuleScope;
 194
 195 void ConfigCompiler::Compile(void)
 196 {
 197         m_ModuleScope = make_shared<Dictionary>();
 198
 199         try {
 200                 yyparse(this);
 201         } catch (const ConfigError& ex) {
 202                 const DebugInfo *di = boost::get_error_info<errinfo_debuginfo>(ex);
 203                 ConfigCompilerContext::GetInstance()->AddMessage(true, ex.what(), di ? *di : DebugInfo());
 204         } catch (const std::exception& ex) {
 205                 ConfigCompilerContext::GetInstance()->AddMessage(true, DiagnosticInformation(ex));
 206         }
 207 }
 208
 209 #define scanner (context->GetScanner())
 210
 211 %}
 212
 213 %%
 214 statements: /* empty */
 215         | statements statement
 216         ;
 217
 218 statement: object | type | include | include_recursive | library | variable | apply
 219         { }
 220         | lterm
 221         {
 222                 AExpression::Ptr aexpr = *$1;
 223                 aexpr->Evaluate(m_ModuleScope);
 224                 delete $1;
 225         }
 226         ;
 227
 228 include: T_INCLUDE rterm
 229         {
 230                 AExpression::Ptr aexpr = static_cast<AExpression::Ptr>(*$2);
 231                 delete $2;
 232
 233                 context->HandleInclude(aexpr->Evaluate(m_ModuleScope), false, DebugInfoRange(@1, @2));
 234         }
 235         | T_INCLUDE T_STRING_ANGLE
 236         {
 237                 context->HandleInclude($2, true, DebugInfoRange(@1, @2));
 238                 free($2);
 239         }
 240         ;
 241
 242 include_recursive: T_INCLUDE_RECURSIVE rterm
 243         {
 244                 AExpression::Ptr aexpr = static_cast<AExpression::Ptr>(*$2);
 245                 delete $2;
 246
 247                 context->HandleIncludeRecursive(aexpr->Evaluate(m_ModuleScope), "*.conf", DebugInfoRange(@1, @2));
 248         }
 249         | T_INCLUDE_RECURSIVE rterm rterm
 250         {
 251                 AExpression::Ptr aexpr1 = static_cast<AExpression::Ptr>(*$2);
 252                 delete $2;
 253
 254                 AExpression::Ptr aexpr2 = static_cast<AExpression::Ptr>(*$3);
 255                 delete $3;
 256
 257                 context->HandleIncludeRecursive(aexpr1->Evaluate(m_ModuleScope), aexpr2->Evaluate(m_ModuleScope), DebugInfoRange(@1, @3));
 258         }
 259         ;
 260
 261 library: T_LIBRARY T_STRING
 262         {
 263                 context->HandleLibrary($2);
 264                 free($2);
 265         }
 266         ;
 267
 268 variable: variable_decl identifier T_SET rterm
 269         {
 270                 AExpression::Ptr aexpr = static_cast<AExpression::Ptr>(*$4);
 271                 delete $4;
 272
 273                 ScriptVariable::Ptr sv = ScriptVariable::Set($2, aexpr->Evaluate(m_ModuleScope));
 274                 sv->SetConstant(true);
 275
 276                 free($2);
 277         }
 278         ;
 279
 280 variable_decl: T_VAR
 281         {
 282                 $$ = true;
 283         }
 284         | T_CONST
 285         {
 286                 $$ = false;
 287         }
 288         ;
 289
 290 identifier: T_IDENTIFIER
 291         | T_STRING
 292         {
 293                 $$ = $1;
 294         }
 295         ;
 296
 297 type: partial_specifier T_TYPE identifier
 298         {
 299                 String name = String($3);
 300                 free($3);
 301
 302                 m_Type = ConfigType::GetByName(name);
 303
 304                 if (!m_Type) {
 305                         if ($1)
 306                                 BOOST_THROW_EXCEPTION(ConfigError("Partial type definition for unknown type '" + name + "'") << errinfo_debuginfo(DebugInfoRange(@1, @3)));
 307
 308                         m_Type = make_shared<ConfigType>(name, DebugInfoRange(@1, @3));
 309                         m_Type->Register();
 310                 }
 311         }
 312         type_inherits_specifier typerulelist
 313         {
 314                 TypeRuleList::Ptr ruleList = *$6;
 315                 m_Type->GetRuleList()->AddRules(ruleList);
 316                 m_Type->GetRuleList()->AddRequires(ruleList);
 317
 318                 String validator = ruleList->GetValidator();
 319                 if (!validator.IsEmpty())
 320                         m_Type->GetRuleList()->SetValidator(validator);
 321
 322                 delete $6;
 323         }
 324         ;
 325
 326 partial_specifier: /* Empty */
 327         {
 328                 $$ = 0;
 329         }
 330         | T_PARTIAL
 331         {
 332                 $$ = 1;
 333         }
 334         ;
 335
 336 typerulelist: '{'
 337         {
 338                 m_RuleLists.push(make_shared<TypeRuleList>());
 339         }
 340         typerules
 341         '}'
 342         {
 343                 $$ = new Value(m_RuleLists.top());
 344                 m_RuleLists.pop();
 345         }
 346         ;
 347
 348 typerules: typerules_inner
 349         | typerules_inner ','
 350
 351 typerules_inner: /* empty */
 352         | typerule
 353         | typerules_inner ',' typerule
 354         ;
 355
 356 typerule: T_REQUIRE T_STRING
 357         {
 358                 m_RuleLists.top()->AddRequire($2);
 359                 free($2);
 360         }
 361         | T_VALIDATOR T_STRING
 362         {
 363                 m_RuleLists.top()->SetValidator($2);
 364                 free($2);
 365         }
 366         | T_ATTRIBUTE type T_STRING
 367         {
 368                 TypeRule rule($2, String(), $3, TypeRuleList::Ptr(), DebugInfoRange(@1, @3));
 369                 free($3);
 370
 371                 m_RuleLists.top()->AddRule(rule);
 372         }
 373         | T_ATTRIBUTE T_TYPE_NAME '(' identifier ')' T_STRING
 374         {
 375                 TypeRule rule($2, $4, $6, TypeRuleList::Ptr(), DebugInfoRange(@1, @6));
 376                 free($4);
 377                 free($6);
 378
 379                 m_RuleLists.top()->AddRule(rule);
 380         }
 381         | T_ATTRIBUTE type T_STRING typerulelist
 382         {
 383                 TypeRule rule($2, String(), $3, *$4, DebugInfoRange(@1, @4));
 384                 free($3);
 385                 delete $4;
 386                 m_RuleLists.top()->AddRule(rule);
 387         }
 388         ;
 389
 390 type_inherits_specifier: /* empty */
 391         | T_INHERITS identifier
 392         {
 393                 m_Type->SetParent($2);
 394                 free($2);
 395         }
 396         ;
 397
 398 type: T_TYPE_DICTIONARY
 399         | T_TYPE_ARRAY
 400         | T_TYPE_NUMBER
 401         | T_TYPE_STRING
 402         | T_TYPE_SCALAR
 403         | T_TYPE_ANY
 404         | T_TYPE_NAME
 405         {
 406                 $$ = $1;
 407         }
 408         ;
 409
 410 object:
 411         {
 412                 m_Abstract = false;
 413         }
 414         object_declaration identifier rterm object_inherits_specifier rterm_scope
 415         {
 416                 DebugInfo di = DebugInfoRange(@2, @6);
 417                 ConfigItemBuilder::Ptr item = make_shared<ConfigItemBuilder>(di);
 418
 419                 AExpression::Ptr aexpr = static_cast<AExpression::Ptr>(*$4);
 420                 delete $4;
 421
 422                 String name = aexpr->Evaluate(m_ModuleScope);
 423
 424                 ConfigItem::Ptr oldItem = ConfigItem::GetObject($3, name);
 425
 426                 if (oldItem) {
 427                         std::ostringstream msgbuf;
 428                         msgbuf << "Object '" << name << "' of type '" << $3 << "' re-defined: " << di << "; previous definition: " << oldItem->GetDebugInfo();
 429                         free($3);
 430                         delete $5;
 431                         BOOST_THROW_EXCEPTION(ConfigError(msgbuf.str()) << errinfo_debuginfo(di));
 432                 }
 433
 434                 item->SetType($3);
 435
 436                 if (name.FindFirstOf("!") != String::NPos) {
 437                         std::ostringstream msgbuf;
 438                         msgbuf << "Name for object '" << name << "' of type '" << $3 << "' is invalid: Object names may not contain '!'";
 439                         free($3);
 440                         BOOST_THROW_EXCEPTION(ConfigError(msgbuf.str()) << errinfo_debuginfo(@4));
 441                 }
 442
 443                 free($3);
 444
 445                 item->SetName(name);
 446
 447                 if ($5) {
 448                         BOOST_FOREACH(const String& parent, *$5) {
 449                                 item->AddParent(parent);
 450                         }
 451
 452                         delete $5;
 453                 }
 454
 455                 AExpression::Ptr exprl = static_cast<AExpression::Ptr>(*$6);
 456                 delete $6;
 457
 458                 exprl->MakeInline();
 459                 item->AddExpression(exprl);
 460
 461                 item->SetAbstract(m_Abstract);
 462
 463                 item->Compile()->Register();
 464                 item.reset();
 465         }
 466         ;
 467
 468 object_declaration: T_OBJECT
 469         | T_TEMPLATE
 470         {
 471                 m_Abstract = true;
 472         }
 473
 474 object_inherits_list:
 475         {
 476                 $$ = NULL;
 477         }
 478         | T_STRING
 479         {
 480                 $$ = new std::vector<String>();
 481                 $$->push_back($1);
 482                 free($1);
 483         }
 484         | object_inherits_list ',' T_STRING
 485         {
 486                 if ($1)
 487                         $$ = $1;
 488                 else
 489                         $$ = new std::vector<String>();
 490
 491                 $$->push_back($3);
 492                 free($3);
 493         }
 494         ;
 495
 496 object_inherits_specifier:
 497         {
 498                 $$ = NULL;
 499         }
 500         | T_INHERITS object_inherits_list
 501         {
 502                 $$ = $2;
 503         }
 504         ;
 505
 506 lbinary_op: T_SET
 507         | T_SET_PLUS
 508         | T_SET_MINUS
 509         | T_SET_MULTIPLY
 510         | T_SET_DIVIDE
 511         {
 512                 $$ = $1;
 513         }
 514         ;
 515
 516 lterm_items: lterm_items_inner
 517         {
 518                 $$ = $1;
 519         }
 520         | lterm_items_inner ','
 521         {
 522                 $$ = $1;
 523         }
 524
 525 lterm_items_inner: /* empty */
 526         {
 527                 $$ = new Array();
 528         }
 529         | lterm
 530         {
 531                 $$ = new Array();
 532                 $$->Add(*$1);
 533                 delete $1;
 534         }
 535         | lterm_items_inner ',' lterm
 536         {
 537                 if ($1)
 538                         $$ = $1;
 539                 else
 540                         $$ = new Array();
 541
 542                 $$->Add(*$3);
 543                 delete $3;
 544         }
 545         ;
 546
 547 lterm: identifier lbinary_op rterm
 548         {
 549                 AExpression::Ptr aexpr = static_cast<AExpression::Ptr>(*$3);
 550                 if ($2 == &AExpression::OpSetPlus || $2 == &AExpression::OpSetMinus || $2 == &AExpression::OpSetMultiply || $2 == &AExpression::OpSetDivide)
 551                         aexpr->MakeInline();
 552
 553                 $$ = new Value(make_shared<AExpression>($2, $1, aexpr, DebugInfoRange(@1, @3)));
 554                 free($1);
 555                 delete $3;
 556         }
 557         | identifier '[' T_STRING ']' lbinary_op rterm
 558         {
 559                 AExpression::Ptr subexpr = make_shared<AExpression>($5, $3, static_cast<AExpression::Ptr>(*$6), DebugInfoRange(@1, @6));
 560                 free($3);
 561                 delete $6;
 562
 563                 Array::Ptr subexprl = make_shared<Array>();
 564                 subexprl->Add(subexpr);
 565
 566                 AExpression::Ptr expr = make_shared<AExpression>(&AExpression::OpDict, subexprl, DebugInfoRange(@1, @6));
 567                 if ($5 == &AExpression::OpSetPlus || $5 == &AExpression::OpSetMinus || $5 == &AExpression::OpSetMultiply || $5 == &AExpression::OpSetDivide)
 568                         expr->MakeInline();
 569
 570                 $$ = new Value(make_shared<AExpression>(&AExpression::OpSetPlus, $1, expr, DebugInfoRange(@1, @6)));
 571                 free($1);
 572         }
 573         | rterm
 574         {
 575                 $$ = $1;
 576         }
 577         ;
 578
 579 rbinary_op: T_PLUS
 580         | T_MINUS
 581         | T_MULTIPLY
 582         | T_DIVIDE
 583         | T_BINARY_AND
 584         | T_BINARY_OR
 585         | T_LESS_THAN
 586         | T_GREATER_THAN
 587         | T_LESS_THAN_OR_EQUAL
 588         | T_GREATER_THAN_OR_EQUAL
 589         | T_EQUAL
 590         | T_NOT_EQUAL
 591         | T_IN
 592         | T_NOT_IN
 593         | T_LOGICAL_AND
 594         | T_LOGICAL_OR
 595         | T_SHIFT_LEFT
 596         | T_SHIFT_RIGHT
 597         {
 598                 $$ = $1;
 599         }
 600         ;
 601
 602 rterm_items: rterm_items_inner
 603         {
 604                 $$ = $1;
 605         }
 606         | rterm_items_inner ','
 607         {
 608                 $$ = $1;
 609         }
 610         ;
 611
 612 rterm_items_inner: /* empty */
 613         {
 614                 $$ = new Array();
 615         }
 616         | rterm
 617         {
 618                 $$ = new Array();
 619                 $$->Add(*$1);
 620                 delete $1;
 621         }
 622         | rterm_items_inner ',' rterm
 623         {
 624                 if ($1)
 625                         $$ = $1;
 626                 else
 627                         $$ = new Array();
 628
 629                 $$->Add(*$3);
 630                 delete $3;
 631         }
 632         ;
 633
 634 rbinary_op: '+'
 635         {
 636                 $$ = &AExpression::OpAdd;
 637         }
 638         ;
 639
 640 rterm_scope: '{' lterm_items '}'
 641         {
 642                 $$ = new Value(make_shared<AExpression>(&AExpression::OpDict, Array::Ptr($2), DebugInfoRange(@1, @3)));
 643         }
 644         ;
 645
 646 rterm: T_STRING
 647         {
 648                 $$ = new Value(make_shared<AExpression>(&AExpression::OpLiteral, $1, @1));
 649                 free($1);
 650         }
 651         | T_NUMBER
 652         {
 653                 $$ = new Value(make_shared<AExpression>(&AExpression::OpLiteral, $1, @1));
 654         }
 655         | T_NULL
 656         {
 657                 $$ = new Value(make_shared<AExpression>(&AExpression::OpLiteral, Empty, @1));
 658         }
 659         | T_IDENTIFIER '(' rterm_items ')'
 660         {
 661                 Array::Ptr arguments = Array::Ptr($3);
 662                 $$ = new Value(make_shared<AExpression>(&AExpression::OpFunctionCall, $1, make_shared<AExpression>(&AExpression::OpLiteral, arguments, @3), DebugInfoRange(@1, @4)));
 663                 free($1);
 664         }
 665         | T_IDENTIFIER
 666         {
 667                 $$ = new Value(make_shared<AExpression>(&AExpression::OpVariable, $1, @1));
 668                 free($1);
 669         }
 670         | '!' rterm
 671         {
 672                 $$ = new Value(make_shared<AExpression>(&AExpression::OpNegate, static_cast<AExpression::Ptr>(*$2), DebugInfoRange(@1, @2)));
 673                 delete $2;
 674         }
 675         | '~' rterm
 676         {
 677                 $$ = new Value(make_shared<AExpression>(&AExpression::OpNegate, static_cast<AExpression::Ptr>(*$2), DebugInfoRange(@1, @2)));
 678                 delete $2;
 679         }
 680         | identifier '[' T_STRING ']'
 681         {
 682                 $$ = new Value(make_shared<AExpression>(&AExpression::OpIndexer, $1, $3, DebugInfoRange(@1, @4)));
 683                 free($1);
 684                 free($3);
 685         }
 686         | '[' rterm_items ']'
 687         {
 688                 $$ = new Value(make_shared<AExpression>(&AExpression::OpArray, Array::Ptr($2), DebugInfoRange(@1, @3)));
 689         }
 690         | rterm_scope
 691         {
 692                 $$ = $1;
 693         }
 694         | '(' rterm ')'
 695         {
 696                 $$ = $2;
 697         }
 698         | rterm rbinary_op rterm
 699         {
 700                 $$ = new Value(make_shared<AExpression>($2, static_cast<AExpression::Ptr>(*$1), static_cast<AExpression::Ptr>(*$3), DebugInfoRange(@1, @3)));
 701                 delete $1;
 702                 delete $3;
 703         }
 704         ;
 705
 706 optional_template: /* empty */
 707         | T_TEMPLATE
 708         ;
 709
 710 apply: T_APPLY optional_template identifier identifier T_TO identifier T_WHERE rterm
 711         {
 712                 if (!ApplyRule::IsValidCombination($3, $6)) {
 713                         BOOST_THROW_EXCEPTION(ConfigError("'apply' cannot be used with types '" + String($3) + "' and '" + String($6) + "'.") << errinfo_debuginfo(@1));
 714                 }
 715
 716                 Array::Ptr arguments = make_shared<Array>();
 717                 arguments->Add(*$8);
 718                 delete $8;
 719
 720                 AExpression::Ptr aexpr = make_shared<AExpression>(&AExpression::OpFunctionCall, "bool", make_shared<AExpression>(&AExpression::OpLiteral, arguments, @8), @8);
 721
 722                 ApplyRule::AddRule($3, $4, $6, aexpr, DebugInfoRange(@1, @8));
 723         }
 724 %%