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 int ignore_newlines = 0;
  73
  74 static void MakeRBinaryOp(Value** result, AExpression::OpCallback& op, Value *left, Value *right, DebugInfo& diLeft, DebugInfo& diRight)
  75 {
  76         *result = new Value(make_shared<AExpression>(op, *left, *right, DebugInfoRange(diLeft, diRight)));
  77         delete left;
  78         delete right;
  79 }
  80
  81 %}
  82
  83 %pure-parser
  84
  85 %locations
  86 %defines
  87 %error-verbose
  88
  89 %parse-param { ConfigCompiler *context }
  90 %lex-param { void *scanner }
  91
  92 %union {
  93         char *text;
  94         double num;
  95         icinga::Value *variant;
  96         icinga::AExpression::OpCallback op;
  97         icinga::TypeSpecifier type;
  98         std::vector<String> *slist;
  99         Array *array;
 100 }
 101
 102 %token T_NEWLINE "new-line"
 103 %token <text> T_STRING
 104 %token <text> T_STRING_ANGLE
 105 %token <num> T_NUMBER
 106 %token T_NULL
 107 %token <text> T_IDENTIFIER
 108
 109 %token <op> T_SET "= (T_SET)"
 110 %token <op> T_SET_PLUS "+= (T_SET_PLUS)"
 111 %token <op> T_SET_MINUS "-= (T_SET_MINUS)"
 112 %token <op> T_SET_MULTIPLY "*= (T_SET_MULTIPLY)"
 113 %token <op> T_SET_DIVIDE "/= (T_SET_DIVIDE)"
 114
 115 %token <op> T_SHIFT_LEFT "<< (T_SHIFT_LEFT)"
 116 %token <op> T_SHIFT_RIGHT ">> (T_SHIFT_RIGHT)"
 117 %token <op> T_EQUAL "== (T_EQUAL)"
 118 %token <op> T_NOT_EQUAL "!= (T_NOT_EQUAL)"
 119 %token <op> T_IN "in (T_IN)"
 120 %token <op> T_NOT_IN "!in (T_NOT_IN)"
 121 %token <op> T_LOGICAL_AND "&& (T_LOGICAL_AND)"
 122 %token <op> T_LOGICAL_OR "|| (T_LOGICAL_OR)"
 123 %token <op> T_LESS_THAN_OR_EQUAL "<= (T_LESS_THAN_OR_EQUAL)"
 124 %token <op> T_GREATER_THAN_OR_EQUAL ">= (T_GREATER_THAN_OR_EQUAL)"
 125 %token <op> T_PLUS "+ (T_PLUS)"
 126 %token <op> T_MINUS "- (T_MINUS)"
 127 %token <op> T_MULTIPLY "* (T_MULTIPLY)"
 128 %token <op> T_DIVIDE_OP "/ (T_DIVIDE_OP)"
 129 %token <op> T_BINARY_AND "& (T_BINARY_AND)"
 130 %token <op> T_BINARY_OR "| (T_BINARY_OR)"
 131 %token <op> T_LESS_THAN "< (T_LESS_THAN)"
 132 %token <op> T_GREATER_THAN "> (T_GREATER_THAN)"
 133
 134 %token T_CONST "const (T_CONST)"
 135 %token <type> T_TYPE_DICTIONARY "dictionary (T_TYPE_DICTIONARY)"
 136 %token <type> T_TYPE_ARRAY "array (T_TYPE_ARRAY)"
 137 %token <type> T_TYPE_NUMBER "number (T_TYPE_NUMBER)"
 138 %token <type> T_TYPE_STRING "string (T_TYPE_STRING)"
 139 %token <type> T_TYPE_SCALAR "scalar (T_TYPE_SCALAR)"
 140 %token <type> T_TYPE_ANY "any (T_TYPE_ANY)"
 141 %token <type> T_TYPE_NAME "name (T_TYPE_NAME)"
 142 %token T_VALIDATOR "%validator (T_VALIDATOR)"
 143 %token T_REQUIRE "%require (T_REQUIRE)"
 144 %token T_ATTRIBUTE "%attribute (T_ATTRIBUTE)"
 145 %token T_TYPE "type (T_TYPE)"
 146 %token T_OBJECT "object (T_OBJECT)"
 147 %token T_TEMPLATE "template (T_TEMPLATE)"
 148 %token T_INCLUDE "include (T_INCLUDE)"
 149 %token T_INCLUDE_RECURSIVE "include_recursive (T_INCLUDE_RECURSIVE)"
 150 %token T_LIBRARY "library (T_LIBRARY)"
 151 %token T_INHERITS "inherits (T_INHERITS)"
 152 %token T_PARTIAL "partial (T_PARTIAL)"
 153 %token T_APPLY "apply (T_APPLY)"
 154 %token T_TO "to (T_TO)"
 155 %token T_WHERE "where (T_WHERE)"
 156 %token T_IMPORT "import (T_IMPORT)"
 157 %token T_ASSIGN "assign (T_ASSIGN)"
 158 %token T_IGNORE "ignore (T_IGNORE)"
 159 %token T_FUNCTION "function (T_FUNCTION)"
 160 %token T_LAMBDA "lambda (T_LAMBDA)"
 161 %token T_RETURN "return (T_RETURN)"
 162
 163 %type <text> identifier
 164 %type <array> rterm_items
 165 %type <array> rterm_items_inner
 166 %type <array> identifier_items
 167 %type <array> identifier_items_inner
 168 %type <array> lterm_items
 169 %type <array> lterm_items_inner
 170 %type <variant> typerulelist
 171 %type <op> lbinary_op
 172 %type <type> type
 173 %type <num> partial_specifier
 174 %type <variant> rterm
 175 %type <variant> rterm_array
 176 %type <variant> rterm_scope
 177 %type <variant> lterm
 178 %type <variant> object
 179 %type <variant> apply
 180 %type <text> target_type_specifier
 181
 182 %left T_LOGICAL_OR
 183 %left T_LOGICAL_AND
 184 %left T_BINARY_OR
 185 %left T_BINARY_AND
 186 %left T_IN
 187 %left T_NOT_IN
 188 %left T_EQUAL T_NOT_EQUAL
 189 %left T_LESS_THAN T_LESS_THAN_OR_EQUAL T_GREATER_THAN T_GREATER_THAN_OR_EQUAL
 190 %left T_SHIFT_LEFT T_SHIFT_RIGHT
 191 %left T_PLUS T_MINUS
 192 %left T_MULTIPLY T_DIVIDE_OP
 193 %right '!' '~'
 194 %left '.' '(' '['
 195 %right ':'
 196 %{
 197
 198 int yylex(YYSTYPE *lvalp, YYLTYPE *llocp, void *scanner);
 199
 200 void yyerror(YYLTYPE *locp, ConfigCompiler *, const char *err)
 201 {
 202         std::ostringstream message;
 203         message << *locp << ": " << err;
 204         ConfigCompilerContext::GetInstance()->AddMessage(true, message.str(), *locp);
 205 }
 206
 207 int yyparse(ConfigCompiler *context);
 208
 209 static bool m_Abstract;
 210
 211 static std::stack<TypeRuleList::Ptr> m_RuleLists;
 212 static ConfigType::Ptr m_Type;
 213
 214 static Dictionary::Ptr m_ModuleScope;
 215
 216 static bool m_Apply;
 217 static bool m_SeenAssign;
 218 static AExpression::Ptr m_Assign;
 219 static AExpression::Ptr m_Ignore;
 220
 221 void ConfigCompiler::Compile(void)
 222 {
 223         m_ModuleScope = make_shared<Dictionary>();
 224
 225         try {
 226                 yyparse(this);
 227         } catch (const ConfigError& ex) {
 228                 const DebugInfo *di = boost::get_error_info<errinfo_debuginfo>(ex);
 229                 ConfigCompilerContext::GetInstance()->AddMessage(true, ex.what(), di ? *di : DebugInfo());
 230         } catch (const std::exception& ex) {
 231                 ConfigCompilerContext::GetInstance()->AddMessage(true, DiagnosticInformation(ex));
 232         }
 233 }
 234
 235 #define scanner (context->GetScanner())
 236
 237 %}
 238
 239 %%
 240 statements: /* empty */
 241         | statements statement
 242         ;
 243
 244 statement: type | include | include_recursive | library | constant | newlines
 245         { }
 246         | lterm
 247         {
 248                 AExpression::Ptr aexpr = *$1;
 249                 aexpr->Evaluate(m_ModuleScope);
 250                 delete $1;
 251         }
 252         ;
 253
 254 include: T_INCLUDE rterm sep
 255         {
 256                 AExpression::Ptr aexpr = *$2;
 257                 delete $2;
 258
 259                 context->HandleInclude(aexpr->Evaluate(m_ModuleScope), false, DebugInfoRange(@1, @2));
 260         }
 261         | T_INCLUDE T_STRING_ANGLE
 262         {
 263                 context->HandleInclude($2, true, DebugInfoRange(@1, @2));
 264                 free($2);
 265         }
 266         ;
 267
 268 include_recursive: T_INCLUDE_RECURSIVE rterm
 269         {
 270                 AExpression::Ptr aexpr = *$2;
 271                 delete $2;
 272
 273                 context->HandleIncludeRecursive(aexpr->Evaluate(m_ModuleScope), "*.conf", DebugInfoRange(@1, @2));
 274         }
 275         | T_INCLUDE_RECURSIVE rterm ',' rterm
 276         {
 277                 AExpression::Ptr aexpr1 = *$2;
 278                 delete $2;
 279
 280                 AExpression::Ptr aexpr2 = *$4;
 281                 delete $4;
 282
 283                 context->HandleIncludeRecursive(aexpr1->Evaluate(m_ModuleScope), aexpr2->Evaluate(m_ModuleScope), DebugInfoRange(@1, @4));
 284         }
 285         ;
 286
 287 library: T_LIBRARY T_STRING sep
 288         {
 289                 context->HandleLibrary($2);
 290                 free($2);
 291         }
 292         ;
 293
 294 constant: T_CONST identifier T_SET rterm sep
 295         {
 296                 AExpression::Ptr aexpr = *$4;
 297                 delete $4;
 298
 299                 ScriptVariable::Ptr sv = ScriptVariable::Set($2, aexpr->Evaluate(m_ModuleScope));
 300                 sv->SetConstant(true);
 301
 302                 free($2);
 303         }
 304         ;
 305
 306 identifier: T_IDENTIFIER
 307         | T_STRING
 308         {
 309                 $$ = $1;
 310         }
 311         ;
 312
 313 type: partial_specifier T_TYPE identifier
 314         {
 315                 String name = String($3);
 316                 free($3);
 317
 318                 m_Type = ConfigType::GetByName(name);
 319
 320                 if (!m_Type) {
 321                         if ($1)
 322                                 BOOST_THROW_EXCEPTION(ConfigError("Partial type definition for unknown type '" + name + "'") << errinfo_debuginfo(DebugInfoRange(@1, @3)));
 323
 324                         m_Type = make_shared<ConfigType>(name, DebugInfoRange(@1, @3));
 325                         m_Type->Register();
 326                 }
 327         }
 328         type_inherits_specifier typerulelist sep
 329         {
 330                 TypeRuleList::Ptr ruleList = *$6;
 331                 m_Type->GetRuleList()->AddRules(ruleList);
 332                 m_Type->GetRuleList()->AddRequires(ruleList);
 333
 334                 String validator = ruleList->GetValidator();
 335                 if (!validator.IsEmpty())
 336                         m_Type->GetRuleList()->SetValidator(validator);
 337
 338                 delete $6;
 339         }
 340         ;
 341
 342 partial_specifier: /* Empty */
 343         {
 344                 $$ = 0;
 345         }
 346         | T_PARTIAL
 347         {
 348                 $$ = 1;
 349         }
 350         ;
 351
 352 typerulelist: '{'
 353         {
 354                 m_RuleLists.push(make_shared<TypeRuleList>());
 355         }
 356         typerules
 357         '}'
 358         {
 359                 $$ = new Value(m_RuleLists.top());
 360                 m_RuleLists.pop();
 361         }
 362         ;
 363
 364 typerules: typerules_inner
 365         | typerules_inner sep
 366
 367 typerules_inner: /* empty */
 368         | typerule
 369         | typerules_inner sep typerule
 370         ;
 371
 372 typerule: T_REQUIRE T_STRING
 373         {
 374                 m_RuleLists.top()->AddRequire($2);
 375                 free($2);
 376         }
 377         | T_VALIDATOR T_STRING
 378         {
 379                 m_RuleLists.top()->SetValidator($2);
 380                 free($2);
 381         }
 382         | T_ATTRIBUTE type T_STRING
 383         {
 384                 TypeRule rule($2, String(), $3, TypeRuleList::Ptr(), DebugInfoRange(@1, @3));
 385                 free($3);
 386
 387                 m_RuleLists.top()->AddRule(rule);
 388         }
 389         | T_ATTRIBUTE T_TYPE_NAME '(' identifier ')' T_STRING
 390         {
 391                 TypeRule rule($2, $4, $6, TypeRuleList::Ptr(), DebugInfoRange(@1, @6));
 392                 free($4);
 393                 free($6);
 394
 395                 m_RuleLists.top()->AddRule(rule);
 396         }
 397         | T_ATTRIBUTE type T_STRING typerulelist
 398         {
 399                 TypeRule rule($2, String(), $3, *$4, DebugInfoRange(@1, @4));
 400                 free($3);
 401                 delete $4;
 402                 m_RuleLists.top()->AddRule(rule);
 403         }
 404         ;
 405
 406 type_inherits_specifier: /* empty */
 407         | T_INHERITS identifier
 408         {
 409                 m_Type->SetParent($2);
 410                 free($2);
 411         }
 412         ;
 413
 414 type: T_TYPE_DICTIONARY
 415         | T_TYPE_ARRAY
 416         | T_TYPE_NUMBER
 417         | T_TYPE_STRING
 418         | T_TYPE_SCALAR
 419         | T_TYPE_ANY
 420         | T_TYPE_NAME
 421         {
 422                 $$ = $1;
 423         }
 424         ;
 425
 426 object:
 427         {
 428                 m_Abstract = false;
 429         }
 430         object_declaration identifier rterm rterm_scope sep
 431         {
 432                 Array::Ptr args = make_shared<Array>();
 433
 434                 args->Add(m_Abstract);
 435
 436                 args->Add($3);
 437                 free($3);
 438
 439                 args->Add(*$4);
 440                 delete $4;
 441
 442                 AExpression::Ptr exprl = *$5;
 443                 delete $5;
 444                 exprl->MakeInline();
 445
 446                 $$ = new Value(make_shared<AExpression>(&AExpression::OpObject, args, exprl, DebugInfoRange(@2, @5)));
 447         }
 448         ;
 449
 450 object_declaration: T_OBJECT
 451         | T_TEMPLATE
 452         {
 453                 m_Abstract = true;
 454         }
 455
 456 identifier_items: identifier_items_inner
 457         {
 458                 $$ = $1;
 459         }
 460         | identifier_items_inner ','
 461         {
 462                 $$ = $1;
 463         }
 464         ;
 465
 466 identifier_items_inner: /* empty */
 467         {
 468                 $$ = new Array();
 469         }
 470         | identifier
 471         {
 472                 $$ = new Array();
 473                 $$->Add($1);
 474                 free($1);
 475         }
 476         | identifier_items_inner ',' identifier
 477         {
 478                 if ($1)
 479                         $$ = $1;
 480                 else
 481                         $$ = new Array();
 482
 483                 $$->Add($3);
 484                 free($3);
 485         }
 486         ;
 487
 488 lbinary_op: T_SET
 489         | T_SET_PLUS
 490         | T_SET_MINUS
 491         | T_SET_MULTIPLY
 492         | T_SET_DIVIDE
 493         {
 494                 $$ = $1;
 495         }
 496         ;
 497
 498 lterm_items: /* empty */
 499         {
 500                 $$ = new Array();
 501         }
 502         | lterm_items_inner
 503         {
 504                 $$ = $1;
 505         }
 506         | lterm_items_inner sep
 507         {
 508                 $$ = $1;
 509         }
 510
 511 lterm_items_inner: lterm
 512         {
 513                 $$ = new Array();
 514                 $$->Add(*$1);
 515                 delete $1;
 516         }
 517         | lterm_items_inner sep lterm
 518         {
 519                 if ($1)
 520                         $$ = $1;
 521                 else
 522                         $$ = new Array();
 523
 524                 $$->Add(*$3);
 525                 delete $3;
 526         }
 527         ;
 528
 529 lterm: identifier lbinary_op rterm
 530         {
 531                 AExpression::Ptr aindex = make_shared<AExpression>(&AExpression::OpLiteral, $1, @1);
 532                 free($1);
 533
 534                 $$ = new Value(make_shared<AExpression>($2, aindex, *$3, DebugInfoRange(@1, @3)));
 535                 delete $3;
 536         }
 537         | identifier '[' rterm ']' lbinary_op rterm
 538         {
 539                 AExpression::Ptr subexpr = make_shared<AExpression>($5, *$3, *$6, DebugInfoRange(@1, @6));
 540                 delete $3;
 541                 delete $6;
 542
 543                 Array::Ptr subexprl = make_shared<Array>();
 544                 subexprl->Add(subexpr);
 545
 546                 AExpression::Ptr aindex = make_shared<AExpression>(&AExpression::OpLiteral, $1, @1);
 547                 free($1);
 548
 549                 AExpression::Ptr expr = make_shared<AExpression>(&AExpression::OpDict, subexprl, DebugInfoRange(@1, @6));
 550                 $$ = new Value(make_shared<AExpression>(&AExpression::OpSetPlus, aindex, expr, DebugInfoRange(@1, @6)));
 551         }
 552         | identifier '.' T_IDENTIFIER lbinary_op rterm
 553         {
 554                 AExpression::Ptr aindex = make_shared<AExpression>(&AExpression::OpLiteral, $3, @3);
 555                 AExpression::Ptr subexpr = make_shared<AExpression>($4, aindex, *$5, DebugInfoRange(@1, @5));
 556                 free($3);
 557                 delete $5;
 558
 559                 Array::Ptr subexprl = make_shared<Array>();
 560                 subexprl->Add(subexpr);
 561
 562                 AExpression::Ptr aindexl = make_shared<AExpression>(&AExpression::OpLiteral, $1, @1);
 563                 free($1);
 564
 565                 AExpression::Ptr expr = make_shared<AExpression>(&AExpression::OpDict, subexprl, DebugInfoRange(@1, @5));
 566                 $$ = new Value(make_shared<AExpression>(&AExpression::OpSetPlus, aindexl, expr, DebugInfoRange(@1, @5)));
 567         }
 568         | T_IMPORT rterm
 569         {
 570                 AExpression::Ptr avar = make_shared<AExpression>(&AExpression::OpVariable, "type", DebugInfoRange(@1, @2));
 571                 $$ = new Value(make_shared<AExpression>(&AExpression::OpImport, avar, *$2, DebugInfoRange(@1, @2)));
 572                 delete $2;
 573         }
 574         | T_ASSIGN T_WHERE rterm
 575         {
 576                 if (!m_Apply)
 577                         BOOST_THROW_EXCEPTION(ConfigError("'assign' keyword not valid in this context."));
 578
 579                 m_SeenAssign = true;
 580
 581                 m_Assign = make_shared<AExpression>(&AExpression::OpLogicalOr, m_Assign, *$3, DebugInfoRange(@1, @3));
 582                 delete $3;
 583
 584                 $$ = new Value(make_shared<AExpression>(&AExpression::OpLiteral, Empty, DebugInfoRange(@1, @3)));
 585         }
 586         | T_IGNORE T_WHERE rterm
 587         {
 588                 if (!m_Apply)
 589                         BOOST_THROW_EXCEPTION(ConfigError("'ignore' keyword not valid in this context."));
 590
 591                 m_Ignore = make_shared<AExpression>(&AExpression::OpLogicalOr, m_Ignore, *$3, DebugInfoRange(@1, @3));
 592
 593                 delete $3;
 594
 595                 $$ = new Value(make_shared<AExpression>(&AExpression::OpLiteral, Empty, DebugInfoRange(@1, @3)));
 596         }
 597         | T_RETURN rterm
 598         {
 599                 AExpression::Ptr aname = make_shared<AExpression>(&AExpression::OpLiteral, "__result", @1);
 600                 $$ = new Value(make_shared<AExpression>(&AExpression::OpSet, aname, *$2, DebugInfoRange(@1, @2)));
 601                 delete $2;
 602
 603         }
 604         | apply
 605         {
 606                 $$ = $1;
 607         }
 608         | object
 609         {
 610                 $$ = $1;
 611         }
 612         | rterm
 613         {
 614                 $$ = $1;
 615         }
 616         ;
 617
 618 rterm_items: /* empty */
 619         {
 620                 $$ = new Array();
 621         }
 622         | rterm_items_inner
 623         {
 624                 $$ = $1;
 625         }
 626         | rterm_items_inner arraysep
 627         {
 628                 $$ = $1;
 629         }
 630         ;
 631
 632 rterm_items_inner: rterm
 633         {
 634                 $$ = new Array();
 635                 $$->Add(*$1);
 636                 delete $1;
 637         }
 638         | rterm_items_inner arraysep rterm
 639         {
 640                 $$ = $1;
 641                 $$->Add(*$3);
 642                 delete $3;
 643         }
 644         ;
 645
 646 rterm_array: '[' newlines rterm_items newlines ']'
 647         {
 648                 $$ = new Value(make_shared<AExpression>(&AExpression::OpArray, Array::Ptr($3), DebugInfoRange(@1, @5)));
 649         }
 650         | '[' newlines rterm_items ']'
 651         {
 652                 $$ = new Value(make_shared<AExpression>(&AExpression::OpArray, Array::Ptr($3), DebugInfoRange(@1, @4)));
 653         }
 654         | '[' rterm_items newlines ']'
 655         {
 656                 $$ = new Value(make_shared<AExpression>(&AExpression::OpArray, Array::Ptr($2), DebugInfoRange(@1, @4)));
 657         }
 658         | '[' rterm_items ']'
 659         {
 660                 $$ = new Value(make_shared<AExpression>(&AExpression::OpArray, Array::Ptr($2), DebugInfoRange(@1, @3)));
 661         }
 662         ;
 663
 664 rterm_scope: '{' newlines lterm_items newlines '}'
 665         {
 666                 $$ = new Value(make_shared<AExpression>(&AExpression::OpDict, Array::Ptr($3), DebugInfoRange(@1, @5)));
 667         }
 668         | '{' newlines lterm_items '}'
 669         {
 670                 $$ = new Value(make_shared<AExpression>(&AExpression::OpDict, Array::Ptr($3), DebugInfoRange(@1, @4)));
 671         }
 672         | '{' lterm_items newlines '}'
 673         {
 674                 $$ = new Value(make_shared<AExpression>(&AExpression::OpDict, Array::Ptr($2), DebugInfoRange(@1, @4)));
 675         }
 676         | '{' lterm_items '}'
 677         {
 678                 $$ = new Value(make_shared<AExpression>(&AExpression::OpDict, Array::Ptr($2), DebugInfoRange(@1, @3)));
 679         }
 680         ;
 681
 682 rterm: T_STRING
 683         {
 684                 $$ = new Value(make_shared<AExpression>(&AExpression::OpLiteral, $1, @1));
 685                 free($1);
 686         }
 687         | T_NUMBER
 688         {
 689                 $$ = new Value(make_shared<AExpression>(&AExpression::OpLiteral, $1, @1));
 690         }
 691         | T_NULL
 692         {
 693                 $$ = new Value(make_shared<AExpression>(&AExpression::OpLiteral, Empty, @1));
 694         }
 695         | rterm '.' T_IDENTIFIER
 696         {
 697                 $$ = new Value(make_shared<AExpression>(&AExpression::OpIndexer, *$1, make_shared<AExpression>(&AExpression::OpLiteral, $3, @3), DebugInfoRange(@1, @3)));
 698                 delete $1;
 699                 free($3);
 700         }
 701         | rterm '(' rterm_items ')'
 702         {
 703                 Array::Ptr arguments = Array::Ptr($3);
 704                 $$ = new Value(make_shared<AExpression>(&AExpression::OpFunctionCall, *$1, make_shared<AExpression>(&AExpression::OpLiteral, arguments, @3), DebugInfoRange(@1, @4)));
 705                 delete $1;
 706         }
 707         | T_IDENTIFIER
 708         {
 709                 $$ = new Value(make_shared<AExpression>(&AExpression::OpVariable, $1, @1));
 710                 free($1);
 711         }
 712         | '!' rterm
 713         {
 714                 $$ = new Value(make_shared<AExpression>(&AExpression::OpLogicalNegate, *$2, DebugInfoRange(@1, @2)));
 715                 delete $2;
 716         }
 717         | '~' rterm
 718         {
 719                 $$ = new Value(make_shared<AExpression>(&AExpression::OpNegate, *$2, DebugInfoRange(@1, @2)));
 720                 delete $2;
 721         }
 722         | rterm '[' rterm ']'
 723         {
 724                 $$ = new Value(make_shared<AExpression>(&AExpression::OpIndexer, *$1, *$3, DebugInfoRange(@1, @4)));
 725                 delete $1;
 726                 delete $3;
 727         }
 728         | rterm_array
 729         {
 730                 $$ = $1;
 731         }
 732         | rterm_scope
 733         {
 734                 $$ = $1;
 735         }
 736         | '('
 737         {
 738                 ignore_newlines++;
 739         }
 740         rterm ')'
 741         {
 742                 ignore_newlines--;
 743                 $$ = $3;
 744         }
 745         | rterm T_LOGICAL_OR rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 746         | rterm T_LOGICAL_AND rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 747         | rterm T_BINARY_OR rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 748         | rterm T_BINARY_AND rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 749         | rterm T_IN rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 750         | rterm T_NOT_IN rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 751         | rterm T_EQUAL rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 752         | rterm T_NOT_EQUAL rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 753         | rterm T_LESS_THAN rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 754         | rterm T_LESS_THAN_OR_EQUAL rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 755         | rterm T_GREATER_THAN rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 756         | rterm T_GREATER_THAN_OR_EQUAL rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 757         | rterm T_SHIFT_LEFT rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 758         | rterm T_SHIFT_RIGHT rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 759         | rterm T_PLUS rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 760         | rterm T_MINUS rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 761         | rterm T_MULTIPLY rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 762         | rterm T_DIVIDE_OP rterm { MakeRBinaryOp(&$$, $2, $1, $3, @1, @3); }
 763         | T_FUNCTION identifier '(' identifier_items ')' rterm_scope
 764         {
 765                 Array::Ptr arr = make_shared<Array>();
 766
 767                 arr->Add($2);
 768                 free($2);
 769
 770                 AExpression::Ptr aexpr = *$6;
 771                 delete $6;
 772                 aexpr->MakeInline();
 773                 arr->Add(aexpr);
 774
 775                 $$ = new Value(make_shared<AExpression>(&AExpression::OpFunction, arr, Array::Ptr($4), DebugInfoRange(@1, @6)));
 776         }
 777         | T_FUNCTION '(' identifier_items ')' rterm_scope
 778         {
 779                 Array::Ptr arr = make_shared<Array>();
 780
 781                 arr->Add(Empty);
 782
 783                 AExpression::Ptr aexpr = *$5;
 784                 delete $5;
 785                 aexpr->MakeInline();
 786                 arr->Add(aexpr);
 787
 788                 $$ = new Value(make_shared<AExpression>(&AExpression::OpFunction, arr, Array::Ptr($3), DebugInfoRange(@1, @5)));
 789         }
 790         | T_LAMBDA identifier_items ':' rterm
 791         {
 792                 Array::Ptr arr = make_shared<Array>();
 793
 794                 arr->Add(Empty);
 795
 796                 Array::Ptr arrex = make_shared<Array>();
 797                 arrex->Add(make_shared<AExpression>(&AExpression::OpSet, make_shared<AExpression>(&AExpression::OpLiteral, "__result", @4), *$4, @4));
 798                 delete $4;
 799                 AExpression::Ptr aexpr = make_shared<AExpression>(&AExpression::OpDict, arrex, true, @4);
 800
 801                 arr->Add(aexpr);
 802
 803                 $$ = new Value(make_shared<AExpression>(&AExpression::OpFunction, arr, Array::Ptr($2), DebugInfoRange(@1, @4)));
 804         }
 805         ;
 806
 807 target_type_specifier: /* empty */
 808         {
 809                 $$ = strdup("");
 810         }
 811         | T_TO identifier
 812         {
 813                 $$ = $2;
 814         }
 815         ;
 816
 817 apply:
 818         {
 819                 m_Apply = true;
 820                 m_SeenAssign = false;
 821                 m_Assign = make_shared<AExpression>(&AExpression::OpLiteral, false, DebugInfo());
 822                 m_Ignore = make_shared<AExpression>(&AExpression::OpLiteral, false, DebugInfo());
 823         }
 824         T_APPLY identifier rterm target_type_specifier rterm
 825         {
 826                 m_Apply = false;
 827
 828                 String type = $3;
 829                 free($3);
 830                 AExpression::Ptr aname = *$4;
 831                 delete $4;
 832                 String target = $5;
 833                 free($5);
 834
 835                 if (!ApplyRule::IsValidSourceType(type))
 836                         BOOST_THROW_EXCEPTION(ConfigError("'apply' cannot be used with type '" + type + "'") << errinfo_debuginfo(DebugInfoRange(@2, @3)));
 837
 838                 if (!ApplyRule::IsValidTargetType(type, target)) {
 839                         if (target == "") {
 840                                 std::vector<String> types = ApplyRule::GetTargetTypes(type);
 841                                 String typeNames;
 842
 843                                 for (int i = 0; i < types.size(); i++) {
 844                                         if (typeNames != "") {
 845                                                 if (i == types.size() - 1)
 846                                                         typeNames += " or ";
 847                                                 else
 848                                                         typeNames += ", ";
 849                                         }
 850
 851                                         typeNames += "'" + types[i] + "'";
 852                                 }
 853
 854                                 BOOST_THROW_EXCEPTION(ConfigError("'apply' target type is ambiguous (can be one of " + typeNames + "): use 'to' to specify a type") << errinfo_debuginfo(DebugInfoRange(@2, @3)));
 855                         } else
 856                                 BOOST_THROW_EXCEPTION(ConfigError("'apply' target type '" + target + "' is invalid") << errinfo_debuginfo(DebugInfoRange(@2, @5)));
 857                 }
 858
 859                 AExpression::Ptr exprl = *$6;
 860                 delete $6;
 861
 862                 exprl->MakeInline();
 863
 864                 // assign && !ignore
 865                 if (!m_SeenAssign)
 866                         BOOST_THROW_EXCEPTION(ConfigError("'apply' is missing 'assign'") << errinfo_debuginfo(DebugInfoRange(@2, @3)));
 867
 868                 AExpression::Ptr rex = make_shared<AExpression>(&AExpression::OpLogicalNegate, m_Ignore, DebugInfoRange(@2, @5));
 869                 AExpression::Ptr filter = make_shared<AExpression>(&AExpression::OpLogicalAnd, m_Assign, rex, DebugInfoRange(@2, @5));
 870
 871                 Array::Ptr args = make_shared<Array>();
 872                 args->Add(type);
 873                 args->Add(target);
 874                 args->Add(aname);
 875                 args->Add(filter);
 876
 877                 $$ = new Value(make_shared<AExpression>(&AExpression::OpApply, args, exprl, DebugInfoRange(@2, @5)));
 878
 879                 m_Assign.reset();
 880                 m_Ignore.reset();
 881         }
 882         ;
 883
 884 newlines: T_NEWLINE
 885         | newlines T_NEWLINE
 886         ;
 887
 888 /* required separator */
 889 sep: ',' newlines
 890         | ','
 891         | ';' newlines
 892         | ';'
 893         | newlines
 894         ;
 895
 896 arraysep: ',' newlines
 897         | ','
 898         ;
 899
 900 %%