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 "config/i2-config.hpp"
  24 #include "config/configitembuilder.hpp"
  25 #include "config/configtype.hpp"
  26 #include "config/configcompiler.hpp"
  27 #include "config/configcompilercontext.hpp"
  28 #include "config/typerule.hpp"
  29 #include "config/typerulelist.hpp"
  30 #include "config/expression.hpp"
  31 #include "config/applyrule.hpp"
  32 #include "config/objectrule.hpp"
  33 #include "base/value.hpp"
  34 #include "base/utility.hpp"
  35 #include "base/scriptvariable.hpp"
  36 #include "base/exception.hpp"
  37 #include "base/dynamictype.hpp"
  38 #include "base/configerror.hpp"
  39 #include <sstream>
  40 #include <stack>
  41 #include <boost/foreach.hpp>
  42
  43 #define YYLTYPE icinga::DebugInfo
  44 #define YYERROR_VERBOSE
  45
  46 #define YYLLOC_DEFAULT(Current, Rhs, N)                                 \
  47 do {                                                                    \
  48         if (N) {                                                        \
  49                 (Current).Path = YYRHSLOC(Rhs, 1).Path;                 \
  50                 (Current).FirstLine = YYRHSLOC(Rhs, 1).FirstLine;       \
  51                 (Current).FirstColumn = YYRHSLOC(Rhs, 1).FirstColumn;   \
  52                 (Current).LastLine = YYRHSLOC(Rhs, N).LastLine;         \
  53                 (Current).LastColumn = YYRHSLOC(Rhs, N).LastColumn;     \
  54         } else {                                                        \
  55                 (Current).Path = YYRHSLOC(Rhs, 0).Path;                 \
  56                 (Current).FirstLine = (Current).LastLine =              \
  57                 YYRHSLOC(Rhs, 0).LastLine;                              \
  58                 (Current).FirstColumn = (Current).LastColumn =          \
  59                 YYRHSLOC(Rhs, 0).LastColumn;                            \
  60         }                                                               \
  61 } while (0)
  62
  63 #define YY_LOCATION_PRINT(file, loc)                    \
  64 do {                                                    \
  65         std::ostringstream msgbuf;                      \
  66         msgbuf << loc;                                  \
  67         std::string str = msgbuf.str();                 \
  68         fputs(str.c_str(), file);                       \
  69 } while (0)
  70
  71 using namespace icinga;
  72
  73 int ignore_newlines = 0;
  74
  75 template<typename T>
  76 static void MakeRBinaryOp(Expression** result, Expression *left, Expression *right, DebugInfo& diLeft, DebugInfo& diRight)
  77 {
  78         *result = new T(left, right, DebugInfoRange(diLeft, diRight));
  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::Expression *expr;
  96         icinga::Value *variant;
  97         CombinedSetOp csop;
  98         icinga::TypeSpecifier type;
  99         std::vector<String> *slist;
 100         std::vector<Expression *> *elist;
 101         std::pair<String, Expression *> *cvitem;
 102         std::map<String, Expression *> *cvlist;
 103 }
 104
 105 %token T_NEWLINE "new-line"
 106 %token <text> T_STRING
 107 %token <text> T_STRING_ANGLE
 108 %token <num> T_NUMBER
 109 %token T_NULL
 110 %token <text> T_IDENTIFIER
 111
 112 %token <csop> T_SET "= (T_SET)"
 113 %token <csop> T_SET_ADD "+= (T_SET_ADD)"
 114 %token <csop> T_SET_SUBTRACT "-= (T_SET_SUBTRACT)"
 115 %token <csop> T_SET_MULTIPLY "*= (T_SET_MULTIPLY)"
 116 %token <csop> T_SET_DIVIDE "/= (T_SET_DIVIDE)"
 117
 118 %token T_SHIFT_LEFT "<< (T_SHIFT_LEFT)"
 119 %token T_SHIFT_RIGHT ">> (T_SHIFT_RIGHT)"
 120 %token T_EQUAL "== (T_EQUAL)"
 121 %token T_NOT_EQUAL "!= (T_NOT_EQUAL)"
 122 %token T_IN "in (T_IN)"
 123 %token T_NOT_IN "!in (T_NOT_IN)"
 124 %token T_LOGICAL_AND "&& (T_LOGICAL_AND)"
 125 %token T_LOGICAL_OR "|| (T_LOGICAL_OR)"
 126 %token T_LESS_THAN_OR_EQUAL "<= (T_LESS_THAN_OR_EQUAL)"
 127 %token T_GREATER_THAN_OR_EQUAL ">= (T_GREATER_THAN_OR_EQUAL)"
 128 %token T_PLUS "+ (T_PLUS)"
 129 %token T_MINUS "- (T_MINUS)"
 130 %token T_MULTIPLY "* (T_MULTIPLY)"
 131 %token T_DIVIDE_OP "/ (T_DIVIDE_OP)"
 132 %token T_BINARY_AND "& (T_BINARY_AND)"
 133 %token T_BINARY_OR "| (T_BINARY_OR)"
 134 %token T_LESS_THAN "< (T_LESS_THAN)"
 135 %token T_GREATER_THAN "> (T_GREATER_THAN)"
 136
 137 %token T_CONST "const (T_CONST)"
 138 %token T_LOCAL "local (T_LOCAL)"
 139 %token T_USE "use (T_USE)"
 140 %token <type> T_TYPE_DICTIONARY "dictionary (T_TYPE_DICTIONARY)"
 141 %token <type> T_TYPE_ARRAY "array (T_TYPE_ARRAY)"
 142 %token <type> T_TYPE_NUMBER "number (T_TYPE_NUMBER)"
 143 %token <type> T_TYPE_STRING "string (T_TYPE_STRING)"
 144 %token <type> T_TYPE_SCALAR "scalar (T_TYPE_SCALAR)"
 145 %token <type> T_TYPE_ANY "any (T_TYPE_ANY)"
 146 %token <type> T_TYPE_NAME "name (T_TYPE_NAME)"
 147 %token T_VALIDATOR "%validator (T_VALIDATOR)"
 148 %token T_REQUIRE "%require (T_REQUIRE)"
 149 %token T_ATTRIBUTE "%attribute (T_ATTRIBUTE)"
 150 %token T_TYPE "type (T_TYPE)"
 151 %token T_OBJECT "object (T_OBJECT)"
 152 %token T_TEMPLATE "template (T_TEMPLATE)"
 153 %token T_INCLUDE "include (T_INCLUDE)"
 154 %token T_INCLUDE_RECURSIVE "include_recursive (T_INCLUDE_RECURSIVE)"
 155 %token T_LIBRARY "library (T_LIBRARY)"
 156 %token T_INHERITS "inherits (T_INHERITS)"
 157 %token T_APPLY "apply (T_APPLY)"
 158 %token T_TO "to (T_TO)"
 159 %token T_WHERE "where (T_WHERE)"
 160 %token T_IMPORT "import (T_IMPORT)"
 161 %token T_ASSIGN "assign (T_ASSIGN)"
 162 %token T_IGNORE "ignore (T_IGNORE)"
 163 %token T_APPLY_FOR "for (T_APPLY_FOR)"
 164 %token T_FUNCTION "function (T_FUNCTION)"
 165 %token T_RETURN "return (T_RETURN)"
 166 %token T_FOR "for (T_FOR)"
 167 %token T_SIGNAL "signal (T_SIGNAL)"
 168 %token T_FOLLOWS "=> (T_FOLLOWS)"
 169
 170 %type <text> identifier
 171 %type <elist> rterm_items
 172 %type <elist> rterm_items_inner
 173 %type <slist> identifier_items
 174 %type <slist> identifier_items_inner
 175 %type <elist> indexer
 176 %type <elist> indexer_items
 177 %type <expr> indexer_item
 178 %type <elist> lterm_items
 179 %type <elist> lterm_items_inner
 180 %type <variant> typerulelist
 181 %type <csop> combined_set_op
 182 %type <type> type
 183 %type <expr> rterm
 184 %type <expr> rterm_array
 185 %type <expr> rterm_scope
 186 %type <expr> lterm
 187 %type <expr> object
 188 %type <expr> apply
 189 %type <expr> optional_rterm
 190 %type <text> target_type_specifier
 191 %type <cvlist> use_specifier
 192 %type <cvlist> use_specifier_items
 193 %type <cvitem> use_specifier_item
 194
 195 %right T_INCLUDE T_INCLUDE_RECURSIVE T_OBJECT T_TEMPLATE T_APPLY T_IMPORT T_ASSIGN T_IGNORE T_WHERE
 196 %right T_FUNCTION T_SIGNAL T_FOR
 197 %left T_LOGICAL_OR
 198 %left T_LOGICAL_AND
 199 %left T_LOCAL T_RETURN
 200 %left T_IDENTIFIER
 201 %left T_SET T_SET_ADD T_SET_SUBTRACT T_SET_MULTIPLY T_SET_DIVIDE
 202 %left T_BINARY_OR
 203 %left T_BINARY_AND
 204 %left T_IN T_NOT_IN
 205 %nonassoc T_EQUAL T_NOT_EQUAL
 206 %nonassoc T_LESS_THAN T_LESS_THAN_OR_EQUAL T_GREATER_THAN T_GREATER_THAN_OR_EQUAL
 207 %left T_SHIFT_LEFT T_SHIFT_RIGHT
 208 %left T_PLUS T_MINUS
 209 %left T_MULTIPLY T_DIVIDE_OP
 210 %right '!' '~'
 211 %left '.' '(' '['
 212 %right ';' ','
 213 %right T_NEWLINE
 214 %{
 215
 216 int yylex(YYSTYPE *lvalp, YYLTYPE *llocp, void *scanner);
 217
 218 void yyerror(YYLTYPE *locp, ConfigCompiler *, const char *err)
 219 {
 220         std::ostringstream message;
 221         message << *locp << ": " << err;
 222         ConfigCompilerContext::GetInstance()->AddMessage(true, message.str(), *locp);
 223 }
 224
 225 int yyparse(ConfigCompiler *context);
 226
 227 static std::stack<bool> m_Abstract;
 228
 229 static std::stack<TypeRuleList::Ptr> m_RuleLists;
 230 static ConfigType::Ptr m_Type;
 231
 232 static std::stack<bool> m_Apply;
 233 static std::stack<bool> m_ObjectAssign;
 234 static std::stack<bool> m_SeenAssign;
 235 static std::stack<Expression *> m_Assign;
 236 static std::stack<Expression *> m_Ignore;
 237 static std::stack<String> m_FKVar;
 238 static std::stack<String> m_FVVar;
 239 static std::stack<Expression *> m_FTerm;
 240 static std::stack<std::vector<Expression *> > m_Expressions;
 241
 242 Expression *ConfigCompiler::Compile(void)
 243 {
 244         m_Abstract = std::stack<bool>();
 245         m_RuleLists = std::stack<TypeRuleList::Ptr>();
 246         m_Type.reset();
 247         m_Apply = std::stack<bool>();
 248         m_ObjectAssign = std::stack<bool>();
 249         m_SeenAssign = std::stack<bool>();
 250         m_Assign = std::stack<Expression *>();
 251         m_Ignore = std::stack<Expression *>();
 252         m_FKVar = std::stack<String>();
 253         m_FVVar = std::stack<String>();
 254         m_FTerm = std::stack<Expression *>();
 255         m_Expressions.push(std::vector<Expression *>());
 256
 257         try {
 258                 if (yyparse(this) != 0)
 259                         BOOST_THROW_EXCEPTION(ConfigError("Syntax error"));
 260
 261                 DictExpression *expr = new DictExpression(m_Expressions.top());
 262                 m_Expressions.pop();
 263                 expr->MakeInline();
 264                 return expr;
 265         } catch (const ConfigError& ex) {
 266                 const DebugInfo *di = boost::get_error_info<errinfo_debuginfo>(ex);
 267                 ConfigCompilerContext::GetInstance()->AddMessage(true, ex.what(), di ? *di : DebugInfo());
 268         } catch (const std::exception& ex) {
 269                 ConfigCompilerContext::GetInstance()->AddMessage(true, DiagnosticInformation(ex));
 270         }
 271
 272         m_Expressions.pop();
 273
 274         return NULL;
 275 }
 276
 277 #define scanner (context->GetScanner())
 278
 279 %}
 280
 281 %%
 282 statements: statement sep
 283         | statements statement sep
 284         ;
 285
 286 statement: type | library | constant
 287         { }
 288         | lterm
 289         {
 290                 printf("lterm!\n");
 291                 m_Expressions.top().push_back($1);
 292         }
 293         ;
 294
 295 library: T_LIBRARY T_STRING
 296         {
 297                 context->HandleLibrary($2);
 298                 free($2);
 299         }
 300         ;
 301
 302 constant: T_CONST identifier T_SET rterm
 303         {
 304                 VMFrame frame;
 305                 ScriptVariable::Ptr sv = ScriptVariable::Set($2, $4->Evaluate(frame));
 306                 free($2);
 307                 delete $4;
 308
 309                 sv->SetConstant(true);
 310         }
 311         ;
 312
 313 identifier: T_IDENTIFIER
 314         | T_STRING
 315         {
 316                 $$ = $1;
 317         }
 318         ;
 319
 320 type: T_TYPE identifier
 321         {
 322                 String name = String($2);
 323                 free($2);
 324
 325                 m_Type = ConfigType::GetByName(name);
 326
 327                 if (!m_Type) {
 328                         m_Type = new ConfigType(name, DebugInfoRange(@1, @2));
 329                         m_Type->Register();
 330                 }
 331         }
 332         type_inherits_specifier typerulelist
 333         {
 334                 TypeRuleList::Ptr ruleList = *$5;
 335                 delete $5;
 336
 337                 m_Type->GetRuleList()->AddRules(ruleList);
 338                 m_Type->GetRuleList()->AddRequires(ruleList);
 339
 340                 String validator = ruleList->GetValidator();
 341                 if (!validator.IsEmpty())
 342                         m_Type->GetRuleList()->SetValidator(validator);
 343         }
 344         ;
 345
 346 typerulelist: '{'
 347         {
 348                 m_RuleLists.push(new TypeRuleList());
 349         }
 350         typerules
 351         '}'
 352         {
 353                 $$ = new Value(m_RuleLists.top());
 354                 m_RuleLists.pop();
 355         }
 356         ;
 357
 358 typerules: typerules_inner
 359         | typerules_inner sep
 360
 361 typerules_inner: /* empty */
 362         | typerule
 363         | typerules_inner sep typerule
 364         ;
 365
 366 typerule: T_REQUIRE T_STRING
 367         {
 368                 m_RuleLists.top()->AddRequire($2);
 369                 free($2);
 370         }
 371         | T_VALIDATOR T_STRING
 372         {
 373                 m_RuleLists.top()->SetValidator($2);
 374                 free($2);
 375         }
 376         | T_ATTRIBUTE type T_STRING
 377         {
 378                 TypeRule rule($2, String(), $3, TypeRuleList::Ptr(), DebugInfoRange(@1, @3));
 379                 free($3);
 380
 381                 m_RuleLists.top()->AddRule(rule);
 382         }
 383         | T_ATTRIBUTE T_TYPE_NAME '(' identifier ')' T_STRING
 384         {
 385                 TypeRule rule($2, $4, $6, TypeRuleList::Ptr(), DebugInfoRange(@1, @6));
 386                 free($4);
 387                 free($6);
 388
 389                 m_RuleLists.top()->AddRule(rule);
 390         }
 391         | T_ATTRIBUTE type T_STRING typerulelist
 392         {
 393                 TypeRule rule($2, String(), $3, *$4, DebugInfoRange(@1, @4));
 394                 free($3);
 395                 delete $4;
 396                 m_RuleLists.top()->AddRule(rule);
 397         }
 398         ;
 399
 400 type_inherits_specifier: /* empty */
 401         | T_INHERITS identifier
 402         {
 403                 m_Type->SetParent($2);
 404                 free($2);
 405         }
 406         ;
 407
 408 type: T_TYPE_DICTIONARY
 409         | T_TYPE_ARRAY
 410         | T_TYPE_NUMBER
 411         | T_TYPE_STRING
 412         | T_TYPE_SCALAR
 413         | T_TYPE_ANY
 414         | T_TYPE_NAME
 415         {
 416                 $$ = $1;
 417         }
 418         ;
 419
 420 object:
 421         {
 422                 m_Abstract.push(false);
 423                 m_ObjectAssign.push(true);
 424                 m_SeenAssign.push(false);
 425                 m_Assign.push(NULL);
 426                 m_Ignore.push(NULL);
 427         }
 428         object_declaration identifier rterm use_specifier rterm_scope
 429         {
 430                 m_ObjectAssign.pop();
 431
 432                 bool abstract = m_Abstract.top();
 433                 m_Abstract.pop();
 434
 435                 String type = $3;
 436                 free($3);
 437
 438                 DictExpression *exprl = dynamic_cast<DictExpression *>($6);
 439                 exprl->MakeInline();
 440
 441                 bool seen_assign = m_SeenAssign.top();
 442                 m_SeenAssign.pop();
 443
 444                 Expression *ignore = m_Ignore.top();
 445                 m_Ignore.pop();
 446
 447                 Expression *assign = m_Assign.top();
 448                 m_Assign.pop();
 449
 450                 Expression *filter = NULL;
 451
 452                 if (seen_assign) {
 453                         if (!ObjectRule::IsValidSourceType(type))
 454                                 BOOST_THROW_EXCEPTION(ConfigError("object rule 'assign' cannot be used for type '" + type + "'") << errinfo_debuginfo(DebugInfoRange(@2, @3)));
 455
 456                         if (ignore) {
 457                                 Expression *rex = new LogicalNegateExpression(ignore, DebugInfoRange(@2, @5));
 458
 459                                 filter = new LogicalAndExpression(assign, rex, DebugInfoRange(@2, @5));
 460                         } else
 461                                 filter = assign;
 462                 }
 463
 464                 $$ = new ObjectExpression(abstract, type, $4, filter, context->GetZone(), $5, exprl, DebugInfoRange(@2, @5));
 465         }
 466         ;
 467
 468 object_declaration: T_OBJECT
 469         | T_TEMPLATE
 470         {
 471                 m_Abstract.top() = true;
 472         }
 473
 474 identifier_items: identifier_items_inner
 475         {
 476                 $$ = $1;
 477         }
 478         | identifier_items_inner ','
 479         {
 480                 $$ = $1;
 481         }
 482         ;
 483
 484 identifier_items_inner: /* empty */
 485         {
 486                 $$ = new std::vector<String>();
 487         }
 488         | identifier
 489         {
 490                 $$ = new std::vector<String>();
 491                 $$->push_back($1);
 492                 free($1);
 493         }
 494         | identifier_items_inner ',' identifier
 495         {
 496                 if ($1)
 497                         $$ = $1;
 498                 else
 499                         $$ = new std::vector<String>();
 500
 501                 $$->push_back($3);
 502                 free($3);
 503         }
 504         ;
 505
 506 indexer: identifier
 507         {
 508                 $$ = new std::vector<Expression *>();
 509                 $$->push_back(MakeLiteral($1));
 510                 free($1);
 511         }
 512         | identifier indexer_items
 513         {
 514                 $$ = $2;
 515                 $$->insert($$->begin(), MakeLiteral($1));
 516                 free($1);
 517         }
 518         ;
 519
 520 indexer_items: indexer_item
 521         {
 522                 $$ = new std::vector<Expression *>();
 523                 $$->push_back($1);
 524         }
 525         | indexer_items indexer_item
 526         {
 527                 $$ = $1;
 528                 $$->push_back($2);
 529         }
 530         ;
 531
 532 indexer_item: '.' identifier
 533         {
 534                 $$ = MakeLiteral($2);
 535                 free($2);
 536         }
 537         | '[' rterm ']'
 538         {
 539                 $$ = $2;
 540         }
 541         ;
 542
 543 combined_set_op: T_SET
 544         | T_SET_ADD
 545         | T_SET_SUBTRACT
 546         | T_SET_MULTIPLY
 547         | T_SET_DIVIDE
 548         {
 549                 $$ = $1;
 550         }
 551         ;
 552
 553 lterm_items: /* empty */
 554         {
 555                 $$ = new std::vector<Expression *>();
 556         }
 557         | lterm_items_inner
 558         {
 559                 $$ = $1;
 560         }
 561         | lterm_items_inner sep
 562         {
 563                 $$ = $1;
 564         }
 565
 566 lterm_items_inner: lterm
 567         {
 568                 $$ = new std::vector<Expression *>();
 569                 $$->push_back($1);
 570         }
 571         | lterm_items_inner sep lterm
 572         {
 573                 if ($1)
 574                         $$ = $1;
 575                 else
 576                         $$ = new std::vector<Expression *>();
 577
 578                 $$->push_back($3);
 579         }
 580         ;
 581
 582 lterm: T_LOCAL indexer combined_set_op rterm
 583         {
 584                 $$ = new SetExpression(*$2, $3, $4, true, DebugInfoRange(@1, @4));
 585                 delete $2;
 586         }
 587         | indexer combined_set_op rterm
 588         {
 589                 $$ = new SetExpression(*$1, $2, $3, false, DebugInfoRange(@1, @3));
 590                 delete $1;
 591         }
 592         | T_INCLUDE rterm
 593         {
 594                 VMFrame frame;
 595                 $$ = context->HandleInclude($2->Evaluate(frame), false, DebugInfoRange(@1, @2));
 596                 delete $2;
 597         }
 598         | T_INCLUDE T_STRING_ANGLE
 599         {
 600                 $$ = context->HandleInclude($2, true, DebugInfoRange(@1, @2));
 601                 free($2);
 602         }
 603         | T_INCLUDE_RECURSIVE rterm
 604         {
 605                 VMFrame frame;
 606                 $$ = context->HandleIncludeRecursive($2->Evaluate(frame), "*.conf", DebugInfoRange(@1, @2));
 607                 delete $2;
 608         }
 609         | T_INCLUDE_RECURSIVE rterm ',' rterm
 610         {
 611                 VMFrame frame;
 612                 $$ = context->HandleIncludeRecursive($2->Evaluate(frame), $4->Evaluate(frame), DebugInfoRange(@1, @4));
 613                 delete $2;
 614                 delete $4;
 615         }
 616         | T_IMPORT rterm
 617         {
 618                 $$ = new ImportExpression($2, DebugInfoRange(@1, @2));
 619         }
 620         | T_ASSIGN T_WHERE rterm
 621         {
 622                 if ((m_Apply.empty() || !m_Apply.top()) && (m_ObjectAssign.empty() || !m_ObjectAssign.top()))
 623                         BOOST_THROW_EXCEPTION(ConfigError("'assign' keyword not valid in this context."));
 624
 625                 m_SeenAssign.top() = true;
 626
 627                 if (m_Assign.top())
 628                         m_Assign.top() = new LogicalOrExpression(m_Assign.top(), $3, DebugInfoRange(@1, @3));
 629                 else
 630                         m_Assign.top() = $3;
 631
 632                 $$ = MakeLiteral();
 633         }
 634         | T_IGNORE T_WHERE rterm
 635         {
 636                 if ((m_Apply.empty() || !m_Apply.top()) && (m_ObjectAssign.empty() || !m_ObjectAssign.top()))
 637                         BOOST_THROW_EXCEPTION(ConfigError("'ignore' keyword not valid in this context."));
 638
 639                 if (m_Ignore.top())
 640                         m_Ignore.top() = new LogicalOrExpression(m_Ignore.top(), $3, DebugInfoRange(@1, @3));
 641                 else
 642                         m_Ignore.top() = $3;
 643
 644                 $$ = MakeLiteral();
 645         }
 646         | T_RETURN rterm
 647         {
 648                 std::vector<Expression *> vname;
 649                 vname.push_back(MakeLiteral("__result"));
 650                 $$ = new SetExpression(vname, OpSetLiteral, $2, false, DebugInfoRange(@1, @2));
 651         }
 652         | apply
 653         {
 654                 $$ = $1;
 655         }
 656         | object
 657         {
 658                 $$ = $1;
 659         }
 660         | rterm
 661         {
 662                 $$ = $1;
 663         }
 664         ;
 665
 666 rterm_items: /* empty */
 667         {
 668                 $$ = new std::vector<Expression *>();
 669         }
 670         | rterm_items_inner
 671         {
 672                 $$ = $1;
 673         }
 674         | rterm_items_inner arraysep
 675         {
 676                 $$ = $1;
 677         }
 678         ;
 679
 680 rterm_items_inner: rterm
 681         {
 682                 $$ = new std::vector<Expression *>();
 683                 $$->push_back($1);
 684         }
 685         | rterm_items_inner arraysep rterm
 686         {
 687                 $$ = $1;
 688                 $$->push_back($3);
 689         }
 690         ;
 691
 692 rterm_array: '[' newlines rterm_items newlines ']'
 693         {
 694                 $$ = new ArrayExpression(*$3, DebugInfoRange(@1, @5));
 695                 delete $3;
 696         }
 697         | '[' newlines rterm_items ']'
 698         {
 699                 $$ = new ArrayExpression(*$3, DebugInfoRange(@1, @4));
 700                 delete $3;
 701         }
 702         | '[' rterm_items newlines ']'
 703         {
 704                 $$ = new ArrayExpression(*$2, DebugInfoRange(@1, @4));
 705                 delete $2;
 706         }
 707         | '[' rterm_items ']'
 708         {
 709                 $$ = new ArrayExpression(*$2, DebugInfoRange(@1, @3));
 710                 delete $2;
 711         }
 712         ;
 713
 714 rterm_scope: '{' newlines lterm_items newlines '}'
 715         {
 716                 $$ = new DictExpression(*$3, DebugInfoRange(@1, @5));
 717                 delete $3;
 718         }
 719         | '{' newlines lterm_items '}'
 720         {
 721                 $$ = new DictExpression(*$3, DebugInfoRange(@1, @4));
 722                 delete $3;
 723         }
 724         | '{' lterm_items newlines '}'
 725         {
 726                 $$ = new DictExpression(*$2, DebugInfoRange(@1, @4));
 727                 delete $2;
 728         }
 729         | '{' lterm_items '}'
 730         {
 731                 $$ = new DictExpression(*$2, DebugInfoRange(@1, @3));
 732                 delete $2;
 733         }
 734         ;
 735
 736 rterm: T_STRING
 737         {
 738                 $$ = MakeLiteral($1);
 739                 free($1);
 740         }
 741         | T_NUMBER
 742         {
 743                 $$ = MakeLiteral($1);
 744         }
 745         | T_NULL
 746         {
 747                 $$ = MakeLiteral();
 748         }
 749         | rterm '.' T_IDENTIFIER
 750         {
 751                 $$ = new IndexerExpression($1, MakeLiteral($3), DebugInfoRange(@1, @3));
 752                 free($3);
 753         }
 754         | rterm '(' rterm_items ')'
 755         {
 756                 $$ = new FunctionCallExpression($1, *$3, DebugInfoRange(@1, @4));
 757                 delete $3;
 758         }
 759         | T_IDENTIFIER
 760         {
 761                 $$ = new VariableExpression($1, @1);
 762                 free($1);
 763         }
 764         | '!' rterm
 765         {
 766                 $$ = new LogicalNegateExpression($2, DebugInfoRange(@1, @2));
 767         }
 768         | '~' rterm
 769         {
 770                 $$ = new NegateExpression($2, DebugInfoRange(@1, @2));
 771         }
 772         | rterm '[' rterm ']'
 773         {
 774                 $$ = new IndexerExpression($1, $3, DebugInfoRange(@1, @4));
 775         }
 776         | rterm_array
 777         {
 778                 $$ = $1;
 779         }
 780         | rterm_scope
 781         {
 782                 $$ = $1;
 783         }
 784         | '('
 785         {
 786                 ignore_newlines++;
 787         }
 788         rterm ')'
 789         {
 790                 ignore_newlines--;
 791                 $$ = $3;
 792         }
 793         | rterm T_LOGICAL_OR rterm { MakeRBinaryOp<LogicalOrExpression>(&$$, $1, $3, @1, @3); }
 794         | rterm T_LOGICAL_AND rterm { MakeRBinaryOp<LogicalAndExpression>(&$$, $1, $3, @1, @3); }
 795         | rterm T_BINARY_OR rterm { MakeRBinaryOp<BinaryOrExpression>(&$$, $1, $3, @1, @3); }
 796         | rterm T_BINARY_AND rterm { MakeRBinaryOp<BinaryAndExpression>(&$$, $1, $3, @1, @3); }
 797         | rterm T_IN rterm { MakeRBinaryOp<InExpression>(&$$, $1, $3, @1, @3); }
 798         | rterm T_NOT_IN rterm { MakeRBinaryOp<NotInExpression>(&$$, $1, $3, @1, @3); }
 799         | rterm T_EQUAL rterm { MakeRBinaryOp<EqualExpression>(&$$, $1, $3, @1, @3); }
 800         | rterm T_NOT_EQUAL rterm { MakeRBinaryOp<NotEqualExpression>(&$$, $1, $3, @1, @3); }
 801         | rterm T_LESS_THAN rterm { MakeRBinaryOp<LessThanExpression>(&$$, $1, $3, @1, @3); }
 802         | rterm T_LESS_THAN_OR_EQUAL rterm { MakeRBinaryOp<LessThanOrEqualExpression>(&$$, $1, $3, @1, @3); }
 803         | rterm T_GREATER_THAN rterm { MakeRBinaryOp<GreaterThanExpression>(&$$, $1, $3, @1, @3); }
 804         | rterm T_GREATER_THAN_OR_EQUAL rterm { MakeRBinaryOp<GreaterThanOrEqualExpression>(&$$, $1, $3, @1, @3); }
 805         | rterm T_SHIFT_LEFT rterm { MakeRBinaryOp<ShiftLeftExpression>(&$$, $1, $3, @1, @3); }
 806         | rterm T_SHIFT_RIGHT rterm { MakeRBinaryOp<ShiftRightExpression>(&$$, $1, $3, @1, @3); }
 807         | rterm T_PLUS rterm { MakeRBinaryOp<AddExpression>(&$$, $1, $3, @1, @3); }
 808         | rterm T_MINUS rterm { MakeRBinaryOp<SubtractExpression>(&$$, $1, $3, @1, @3); }
 809         | rterm T_MULTIPLY rterm { MakeRBinaryOp<MultiplyExpression>(&$$, $1, $3, @1, @3); }
 810         | rterm T_DIVIDE_OP rterm { MakeRBinaryOp<DivideExpression>(&$$, $1, $3, @1, @3); }
 811         | T_FUNCTION identifier '(' identifier_items ')' use_specifier rterm_scope
 812         {
 813                 DictExpression *aexpr = dynamic_cast<DictExpression *>($7);
 814                 aexpr->MakeInline();
 815
 816                 $$ = new FunctionExpression($2, *$4, $6, aexpr, DebugInfoRange(@1, @6));
 817                 free($2);
 818                 delete $4;
 819         }
 820         | T_FUNCTION '(' identifier_items ')' use_specifier rterm_scope
 821         {
 822                 DictExpression *aexpr = dynamic_cast<DictExpression *>($6);
 823                 aexpr->MakeInline();
 824
 825                 $$ = new FunctionExpression("", *$3, $5, aexpr, DebugInfoRange(@1, @5));
 826                 delete $3;
 827         }
 828         | T_SIGNAL identifier T_SET_ADD rterm
 829         {
 830                 $$ = new SlotExpression($2, $4, DebugInfoRange(@1, @4));
 831                 free($2);
 832         }
 833         | T_FOR '(' identifier T_FOLLOWS identifier T_IN rterm ')' rterm_scope
 834         {
 835                 $$ = new ForExpression($3, $5, $7, $9, DebugInfoRange(@1, @9));
 836                 free($3);
 837                 free($5);
 838         }
 839         | T_FOR '(' identifier T_IN rterm ')' rterm_scope
 840         {
 841                 $$ = new ForExpression($3, "", $5, $7, DebugInfoRange(@1, @7));
 842                 free($3);
 843         }
 844         ;
 845
 846 target_type_specifier: /* empty */
 847         {
 848                 $$ = strdup("");
 849         }
 850         | T_TO identifier
 851         {
 852                 $$ = $2;
 853         }
 854         ;
 855
 856 use_specifier: /* empty */
 857         {
 858                 $$ = NULL;
 859         }
 860         | T_USE '(' use_specifier_items ')'
 861         {
 862                 $$ = $3;
 863         }
 864         ;
 865
 866 use_specifier_items: use_specifier_item
 867         {
 868                 $$ = new std::map<String, Expression *>();
 869                 $$->insert(*$1);
 870                 delete $1;
 871         }
 872         | use_specifier_items ',' use_specifier_item
 873         {
 874                 $$ = $1;
 875                 $$->insert(*$3);
 876                 delete $3;
 877         }
 878         ;
 879
 880 use_specifier_item: identifier
 881         {
 882                 $$ = new std::pair<String, Expression *>($1, new VariableExpression($1, @1));
 883         }
 884         | identifier T_SET rterm
 885         {
 886                 $$ = new std::pair<String, Expression *>($1, $3);
 887         }
 888         ;
 889
 890 apply_for_specifier: /* empty */
 891         | T_APPLY_FOR '(' identifier T_FOLLOWS identifier T_IN rterm ')'
 892         {
 893                 m_FKVar.top() = $3;
 894                 free($3);
 895
 896                 m_FVVar.top() = $5;
 897                 free($5);
 898
 899                 m_FTerm.top() = $7;
 900         }
 901         | T_APPLY_FOR '(' identifier T_IN rterm ')'
 902         {
 903                 m_FKVar.top() = $3;
 904                 free($3);
 905
 906                 m_FVVar.top() = "";
 907
 908                 m_FTerm.top() = $5;
 909         }
 910         ;
 911
 912 optional_rterm: /* empty */
 913         {
 914                 $$ = MakeLiteral();
 915         }
 916         | rterm
 917         {
 918                 $$ = $1;
 919         }
 920         ;
 921
 922 apply:
 923         {
 924                 m_Apply.push(true);
 925                 m_SeenAssign.push(false);
 926                 m_Assign.push(NULL);
 927                 m_Ignore.push(NULL);
 928                 m_FKVar.push("");
 929                 m_FVVar.push("");
 930                 m_FTerm.push(NULL);
 931         }
 932         T_APPLY identifier optional_rterm apply_for_specifier target_type_specifier use_specifier rterm_scope
 933         {
 934                 m_Apply.pop();
 935
 936                 String type = $3;
 937                 free($3);
 938                 String target = $6;
 939                 free($6);
 940
 941                 if (!ApplyRule::IsValidSourceType(type))
 942                         BOOST_THROW_EXCEPTION(ConfigError("'apply' cannot be used with type '" + type + "'") << errinfo_debuginfo(DebugInfoRange(@2, @3)));
 943
 944                 if (!ApplyRule::IsValidTargetType(type, target)) {
 945                         if (target == "") {
 946                                 std::vector<String> types = ApplyRule::GetTargetTypes(type);
 947                                 String typeNames;
 948
 949                                 for (std::vector<String>::size_type i = 0; i < types.size(); i++) {
 950                                         if (typeNames != "") {
 951                                                 if (i == types.size() - 1)
 952                                                         typeNames += " or ";
 953                                                 else
 954                                                         typeNames += ", ";
 955                                         }
 956
 957                                         typeNames += "'" + types[i] + "'";
 958                                 }
 959
 960                                 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)));
 961                         } else
 962                                 BOOST_THROW_EXCEPTION(ConfigError("'apply' target type '" + target + "' is invalid") << errinfo_debuginfo(DebugInfoRange(@2, @5)));
 963                 }
 964
 965                 DictExpression *exprl = dynamic_cast<DictExpression *>($8);
 966                 exprl->MakeInline();
 967
 968                 // assign && !ignore
 969                 if (!m_SeenAssign.top())
 970                         BOOST_THROW_EXCEPTION(ConfigError("'apply' is missing 'assign'") << errinfo_debuginfo(DebugInfoRange(@2, @3)));
 971
 972                 m_SeenAssign.pop();
 973
 974                 Expression *ignore = m_Ignore.top();
 975                 m_Ignore.pop();
 976
 977                 Expression *assign = m_Assign.top();
 978                 m_Assign.pop();
 979
 980                 Expression *filter;
 981
 982                 if (ignore) {
 983                         Expression *rex = new LogicalNegateExpression(ignore, DebugInfoRange(@2, @5));
 984
 985                         filter = new LogicalAndExpression(assign, rex, DebugInfoRange(@2, @5));
 986                 } else
 987                         filter = assign;
 988
 989                 String fkvar = m_FKVar.top();
 990                 m_FKVar.pop();
 991
 992                 String fvvar = m_FVVar.top();
 993                 m_FVVar.pop();
 994
 995                 Expression *fterm = m_FTerm.top();
 996                 m_FTerm.pop();
 997
 998                 $$ = new ApplyExpression(type, target, $4, filter, fkvar, fvvar, fterm, $7, exprl, DebugInfoRange(@2, @7));
 999         }
1000         ;
1001
1002 newlines: T_NEWLINE
1003         | T_NEWLINE newlines
1004         ;
1005
1006 /* required separator */
1007 sep: ',' newlines
1008         | ','
1009         | ';' newlines
1010         | ';'
1011         | newlines
1012         ;
1013
1014 arraysep: ',' newlines
1015         | ','
1016         ;
1017
1018 %%