idlc/source/parser.y

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 /*
  21  * parser.yy - BISON grammar for IDLC 1.0
  22  */
  23
  24 %{
  25 #include <string.h>
  26
  27 #include <idlc.hxx>
  28 #include <errorhandler.hxx>
  29 #include <fehelper.hxx>
  30 #include <astexpression.hxx>
  31 #include <astconstants.hxx>
  32 #include <astconstant.hxx>
  33 #include <astbasetype.hxx>
  34 #include <asttypedef.hxx>
  35 #include <astexception.hxx>
  36 #include <astmember.hxx>
  37 #include <astenum.hxx>
  38 #include <astsequence.hxx>
  39 #include <astattribute.hxx>
  40 #include <astoperation.hxx>
  41 #include <astparameter.hxx>
  42 #include <astinterfacemember.hxx>
  43 #include <astservicemember.hxx>
  44 #include <astobserves.hxx>
  45 #include <astneeds.hxx>
  46
  47 #include <aststructinstance.hxx>
  48
  49 #include "attributeexceptions.hxx"
  50
  51 #include <rtl/strbuf.hxx>
  52 #include <osl/diagnose.h>
  53
  54 #include <algorithm>
  55 #include <vector>
  56
  57
  58 #define YYDEBUG 1
  59 #define YYERROR_VERBOSE 1
  60
  61 extern int yylex(void);
  62 static void yyerror(char const *);
  63
  64 static void checkIdentifier(OString const * id)
  65 {
  66     static short check = 0;
  67     if (check == 0) {
  68         if (idlc()->getOptions()->isValid("-cid"))
  69             check = 1;
  70         else
  71             check = 2;
  72     }
  73
  74     if ( id->indexOf('_') >= 0 )
  75         if ( (id->pData->buffer[0] >= 97 && id->pData->buffer[0] <= 122)
  76              || id->pData->buffer[0] == '_') {
  77             if (check == 1) {
  78                 OStringBuffer msg(25 + id->getLength());
  79                 msg.append("mismatched identifier '");
  80                 msg.append(*id);
  81                 msg.append("'");
  82                 ErrorHandler::syntaxError(idlc()->getParseState(),
  83                                          idlc()->getLineNumber(),
  84                                          msg.getStr());
  85             }
  86             else
  87                 ErrorHandler::warning0(WarningCode::WrongNamingConvention, id->getStr());
  88         }
  89 }
  90
  91 static void reportDoubleMemberDeclarations(
  92     AstInterface::DoubleMemberDeclarations const & doubleMembers)
  93 {
  94     for (auto const& doubleMember : doubleMembers)
  95     {
  96         ErrorHandler::error2(ErrorCode::DoubleMember, doubleMember.first, doubleMember.second);
  97     }
  98 }
  99
 100 static void addInheritedInterface(
 101     AstInterface * ifc, OString const & name, bool optional,
 102     OUString const & documentation)
 103 {
 104     AstDeclaration * decl = ifc->lookupByName(name);
 105     AstDeclaration const * resolved = resolveTypedefs(decl);
 106     if (resolved != nullptr && resolved->getNodeType() == NT_interface) {
 107         if (ErrorHandler::checkPublished(decl)) {
 108             if (!static_cast< AstInterface const * >(resolved)->isDefined()) {
 109                 ErrorHandler::inheritanceError(
 110                     NT_interface, &ifc->getScopedName(), decl);
 111             } else {
 112                 AstInterface::DoubleDeclarations doubleDecls(
 113                     ifc->checkInheritedInterfaceClashes(
 114                         static_cast< AstInterface const * >(resolved),
 115                         optional));
 116                 if (doubleDecls.interfaces.empty()
 117                     && doubleDecls.members.empty())
 118                 {
 119                     ifc->addInheritedInterface(
 120                         static_cast< AstType * >(decl), optional,
 121                         documentation);
 122                 } else {
 123                     for (auto const& elem : doubleDecls.interfaces)
 124                     {
 125                         ErrorHandler::error1(
 126                             ErrorCode::DoubleInheritance, elem);
 127                     }
 128                     reportDoubleMemberDeclarations(doubleDecls.members);
 129                 }
 130             }
 131         }
 132     } else {
 133         ErrorHandler::lookupError(
 134             ErrorCode::InterfaceMemberLookup, name, scopeAsDecl(ifc));
 135     }
 136 }
 137
 138 static AstDeclaration const * createNamedType(
 139     OString const * scopedName, DeclList const * typeArgs)
 140 {
 141     AstDeclaration * decl = idlc()->scopes()->topNonNull()->lookupByName(
 142         *scopedName);
 143     AstDeclaration const * resolved = resolveTypedefs(decl);
 144     if (decl == nullptr) {
 145         ErrorHandler::lookupError(*scopedName);
 146     } else if (!ErrorHandler::checkPublished(decl)) {
 147         decl = nullptr;
 148     } else if (resolved->getNodeType() == NT_struct) {
 149         if (static_cast< AstStruct const * >(resolved)->getTypeParameterCount()
 150             != (typeArgs == nullptr ? 0 : typeArgs->size()))
 151         {
 152             ErrorHandler::error0(ErrorCode::WrongNumberOfTypeArguments);
 153             decl = nullptr;
 154         } else if (typeArgs != nullptr) {
 155             AstScope * global = idlc()->scopes()->bottom();
 156             AstDeclaration * inst = new AstStructInstance(
 157                 static_cast< AstType * >(decl), typeArgs, global);
 158             decl = global->addDeclaration(inst);
 159             if (decl != inst) {
 160                 delete inst;
 161             }
 162         }
 163     } else if (decl->isType()) {
 164         if (typeArgs != nullptr) {
 165             ErrorHandler::error0(ErrorCode::WrongNumberOfTypeArguments);
 166             decl = nullptr;
 167         }
 168     } else {
 169         ErrorHandler::noTypeError(decl);
 170         decl = nullptr;
 171     }
 172     delete scopedName;
 173     delete typeArgs;
 174     return decl;
 175 }
 176
 177 static bool includes(AstDeclaration const * type1, AstDeclaration const * type2) {
 178     OSL_ASSERT(type2 != nullptr);
 179     if (type1 != nullptr) {
 180         if (type1->getNodeType() == NT_instantiated_struct) {
 181             AstStructInstance const * inst
 182                 = static_cast< AstStructInstance const * >(type1);
 183             if (inst->getTypeTemplate() == type2) {
 184                 return true;
 185             }
 186             for (DeclList::const_iterator i(inst->getTypeArgumentsBegin());
 187                  i != inst->getTypeArgumentsEnd(); ++i)
 188             {
 189                 if (includes(*i, type2)) {
 190                     return true;
 191                 }
 192             }
 193         } else if (type1 == type2) {
 194             return true;
 195         }
 196     }
 197     return false;
 198 }
 199
 200 // Suppress any warnings from generated code:
 201 #if defined _MSC_VER
 202 #pragma warning(disable: 4702) // unreachable code
 203 #endif
 204 %}
 205 /*
 206  * Declare the type of values in the grammar
 207  */
 208 %union {
 209     ExprType                etval;     /* Expression type */
 210     AstDeclaration*     dclval;    /* Declaration */
 211     AstDeclaration const * cdclval;
 212     DeclList * dclsval;
 213     AstExpression*      exval;      /* expression value */
 214     FeDeclarator*           fdval;      /* declarator value */
 215     FeDeclList*         dlval;      /* declarator list value */
 216     FeInheritanceHeader*    ihval;      /* inheritance header value */
 217     OString*     sval;       /* OString value */
 218     std::vector< OString > * svals;
 219     sal_Char*           strval; /* sal_Char* value */
 220     bool                bval;       /* sal_Boolean* value */
 221     sal_Int64               ival;       /* sal_Int64 value */
 222     sal_uInt64 uval; /* sal_uInt64 value */
 223     sal_uInt32          ulval;      /* sal_uInt32 value */
 224     double                  dval;       /* double value */
 225     float                   fval;       /* float value */
 226     std::list< OString >*         slval;      /* StringList value */
 227     AttributeExceptions::Part attexcpval;
 228     AttributeExceptions attexcval;
 229 }
 230
 231 /*
 232  * Token types: These are returned by the lexer
 233  */
 234
 235 %token <sval>       IDL_IDENTIFIER
 236 %token          IDL_ATTRIBUTE
 237 %token              IDL_BOUND
 238 %token          IDL_CONST
 239 %token          IDL_CONSTANTS
 240 %token              IDL_CONSTRAINED
 241 %token          IDL_ENUM
 242 %token          IDL_EXCEPTION
 243 %token          IDL_INTERFACE
 244 %token          IDL_MAYBEAMBIGUOUS
 245 %token          IDL_MAYBEDEFAULT
 246 %token          IDL_MAYBEVOID
 247 %token          IDL_MODULE
 248 %token          IDL_NEEDS
 249 %token          IDL_OBSERVES
 250 %token          IDL_OPTIONAL
 251 %token          IDL_PROPERTY
 252 %token          IDL_RAISES
 253 %token          IDL_READONLY
 254 %token          IDL_REMOVABLE
 255 %token          IDL_SERVICE
 256 %token          IDL_SEQUENCE
 257 %token          IDL_SINGLETON
 258 %token          IDL_STRUCT
 259 %token          IDL_TYPEDEF
 260 %token              IDL_TRANSIENT
 261
 262 %token          IDL_ANY
 263 %token          IDL_CHAR
 264 %token          IDL_BOOLEAN
 265 %token          IDL_BYTE
 266 %token          IDL_DOUBLE
 267 %token          IDL_FLOAT
 268 %token          IDL_HYPER
 269 %token          IDL_LONG
 270 %token          IDL_SHORT
 271 %token          IDL_VOID
 272 %token          IDL_STRING
 273 %token          IDL_TYPE
 274 %token          IDL_UNSIGNED
 275
 276 %token          IDL_TRUE
 277 %token          IDL_FALSE
 278
 279 %token          IDL_IN
 280 %token          IDL_OUT
 281 %token          IDL_INOUT
 282
 283 %token IDL_GET
 284 %token IDL_SET
 285
 286 %token IDL_PUBLISHED
 287
 288 %token IDL_ELLIPSIS
 289
 290 %token <strval> IDL_LEFTSHIFT
 291 %token <strval> IDL_RIGHTSHIFT
 292 %token <strval>     IDL_SCOPESEPARATOR
 293
 294 %token <ival>       IDL_INTEGER_LITERAL
 295 %token <uval> IDL_INTEGER_ULITERAL
 296 %token <dval>       IDL_FLOATING_PT_LITERAL
 297
 298 /*
 299  * These are production names:
 300  */
 301 %type <dclval>  type_dcl
 302 %type <dclval>  exception_name
 303 %type <cdclval> constructed_type_spec enum_type op_type_spec
 304 %type <cdclval> sequence_type_spec simple_type_spec struct_type
 305 %type <cdclval> type_spec
 306 %type <cdclval> fundamental_type type_arg type_or_parameter
 307 %type <dclsval> opt_raises raises exception_list
 308 %type <attexcpval> opt_attribute_get_raises attribute_get_raises
 309 %type <attexcpval> opt_attribute_set_raises attribute_set_raises
 310 %type <dclsval> opt_type_args type_args
 311
 312 %type <sval>    identifier
 313 %type <sval>    interface_decl
 314 %type <sval>    scoped_name inheritance_spec
 315 %type <slval>   scoped_names at_least_one_scoped_name
 316
 317 %type <etval>   const_type integer_type char_type boolean_type
 318 %type <etval>   floating_pt_type any_type signed_int string_type
 319 %type <etval>   unsigned_int base_type_spec byte_type type_type
 320
 321 %type <exval>   expression const_expr or_expr xor_expr and_expr
 322 %type <exval>   add_expr mult_expr unary_expr primary_expr shift_expr
 323 %type <exval>   literal
 324
 325 %type <fdval>   declarator
 326 %type <dlval>   declarators at_least_one_declarator
 327
 328 %type <ihval>   exception_header structure_header interfaceheader
 329
 330 %type <ulval>   flag_header opt_attrflags opt_attrflag
 331 %type <ulval>   direction service_interface_header service_service_header
 332
 333 %type <bval>    optional_inherited_interface opt_rest opt_service_body
 334
 335 %type <attexcval> opt_attribute_block attribute_block_rest opt_attribute_raises
 336
 337 %type <svals> opt_type_params type_params
 338
 339 %%
 340 /*
 341  * Grammar start here
 342  */
 343 start : definitions;
 344
 345 definitions :
 346     definition definitions
 347     | /* EMPTY */
 348     ;
 349
 350 definition :
 351     opt_published publishable_definition
 352     | module_dcl
 353     {
 354         idlc()->setParseState(PS_ModuleDeclSeen);
 355     }
 356     ';'
 357     {
 358         idlc()->setParseState(PS_NoState);
 359     }
 360     | error ';'
 361     {
 362         yyerror("definitions");
 363         yyerrok;
 364     }
 365     ;
 366
 367 opt_published:
 368     IDL_PUBLISHED { idlc()->setPublished(true); }
 369     | /* empty */ { idlc()->setPublished(false); }
 370     ;
 371
 372 publishable_definition:
 373     type_dcl
 374     {
 375         idlc()->setParseState(PS_TypeDeclSeen);
 376     }
 377     ';'
 378     {
 379         idlc()->setParseState(PS_NoState);
 380     }
 381     | exception_dcl
 382     {
 383         idlc()->setParseState(PS_ExceptionDeclSeen);
 384     }
 385     ';'
 386     {
 387         idlc()->setParseState(PS_NoState);
 388     }
 389     | interface
 390     {
 391         idlc()->setParseState(PS_InterfaceDeclSeen);
 392     }
 393     ';'
 394     {
 395         idlc()->setParseState(PS_NoState);
 396     }
 397     | service_dcl
 398     {
 399         idlc()->setParseState(PS_ServiceDeclSeen);
 400     }
 401     ';'
 402     {
 403         idlc()->setParseState(PS_NoState);
 404     }
 405     | singleton_dcl
 406     {
 407         idlc()->setParseState(PS_SingletonDeclSeen);
 408     }
 409     ';'
 410     {
 411         idlc()->setParseState(PS_NoState);
 412     }
 413     | constants_dcl
 414     {
 415         idlc()->setParseState(PS_ConstantsDeclSeen);
 416     }
 417     ';'
 418     {
 419         idlc()->setParseState(PS_NoState);
 420     }
 421     ;
 422
 423 module_dcl :
 424     IDL_MODULE
 425     {
 426         idlc()->setParseState(PS_ModuleSeen);
 427         idlc()->setPublished(false);
 428     }
 429     identifier
 430     {
 431         idlc()->setParseState(PS_ModuleIDSeen);
 432         checkIdentifier($3);
 433
 434         AstScope*       pScope = idlc()->scopes()->topNonNull();
 435         AstModule*      pModule = nullptr;
 436
 437         if ( pScope )
 438         {
 439             pModule = new AstModule(*$3, pScope);
 440             if( AstDeclaration* pExists = pScope->lookupForAdd(pModule) )
 441             {
 442                 pExists->setInMainfile(idlc()->isInMainFile());
 443                 pExists->setFileName(pModule->getFileName());
 444                 if (pExists->isPredefined())
 445                 {
 446                     pExists->setPredefined(false);
 447                     if (pExists->getDocumentation().getLength() == 0 &&
 448                         pModule->getDocumentation().getLength() > 0)
 449                     {
 450                         pExists->setDocumentation(pModule->getDocumentation());
 451                     }
 452                 }
 453                 delete(pModule);
 454                 pModule = static_cast<AstModule*>(pExists);
 455             } else
 456             {
 457                 pScope->addDeclaration(pModule);
 458             }
 459             idlc()->scopes()->push(pModule);
 460         }
 461         delete $3;
 462     }
 463     '{'
 464     {
 465         idlc()->setParseState(PS_ModuleSqSeen);
 466     }
 467     definitions
 468     {
 469         idlc()->setParseState(PS_ModuleBodySeen);
 470     }
 471     '}'
 472     {
 473         idlc()->setParseState(PS_ModuleQsSeen);
 474         /*
 475          * Finished with this module - pop it from the scope stack
 476          */
 477         idlc()->scopes()->pop();
 478     }
 479     ;
 480
 481 interface :
 482     interface_dcl
 483     | forward_dcl
 484     ;
 485
 486 interface_decl :
 487     IDL_INTERFACE
 488     {
 489         idlc()->setParseState(PS_InterfaceSeen);
 490     }
 491     identifier
 492     {
 493         idlc()->setParseState(PS_InterfaceIDSeen);
 494         checkIdentifier($3);
 495         $$ = $3;
 496     }
 497     ;
 498
 499 forward_dcl :
 500     interface_decl
 501     {
 502         idlc()->setParseState(PS_ForwardDeclSeen);
 503
 504         AstScope*       pScope = idlc()->scopes()->topNonNull();
 505         AstInterface*   pForward = nullptr;
 506         AstDeclaration* pDecl = nullptr;
 507
 508         /*
 509          * Make a new forward interface node and add it to its enclosing scope
 510          */
 511         if ( pScope && $1 )
 512         {
 513             pForward = new AstInterface(*$1, nullptr, pScope);
 514
 515             pDecl = pScope->lookupByName(pForward->getScopedName());
 516             if ( pDecl )
 517             {
 518                 if ( (pDecl != pForward) &&
 519                      (pDecl->getNodeType() == NT_interface) )
 520                 {
 521                     delete pForward;
 522                 } else
 523                 {
 524                     ErrorHandler::error2(ErrorCode::RedefScope, scopeAsDecl(pScope), pDecl);
 525                 }
 526             } else
 527             {
 528                 /*
 529                  * Add the interface to its definition scope
 530                  */
 531                 pScope->addDeclaration(pForward);
 532             }
 533         }
 534         delete $1;
 535     }
 536     ;
 537
 538 interface_dcl :
 539     interfaceheader
 540     {
 541         idlc()->setParseState(PS_InterfaceHeadSeen);
 542
 543         AstScope*       pScope = idlc()->scopes()->topNonNull();
 544         AstInterface*   pInterface = nullptr;
 545         AstInterface*   pForward = nullptr;
 546
 547         /*
 548          * Make a new interface node and add it to its enclosing scope
 549          */
 550         if ( pScope && $1 )
 551         {
 552             pInterface = new AstInterface(
 553                 *$1->getName(),
 554                 static_cast< AstInterface const * >(resolveTypedefs($1->getInherits())), pScope);
 555             if ( AstDeclaration* pDecl = pScope->lookupByName(pInterface->getScopedName()) )
 556             {
 557                 /*
 558                  * See if we're defining a forward declared interface.
 559                  */
 560                 if (pDecl->getNodeType() == NT_interface)
 561                 {
 562                     pForward = static_cast<AstInterface*>(pDecl);
 563                     if ( !pForward->isDefined() )
 564                     {
 565                         /*
 566                          * Check if redefining in same scope
 567                          */
 568                         if ( pForward->getScope() != pScope )
 569                         {
 570                             if ( pForward->getScopedName() != pInterface->getScopedName() )
 571                             {
 572                                 ErrorHandler::error3(ErrorCode::ScopeConflict,
 573                                          pInterface, pForward, scopeAsDecl(pScope));
 574                             }
 575                         }
 576                         else if ( !pInterface->isPublished()
 577                                   && pForward->isPublished() )
 578                         {
 579                             ErrorHandler::error0(ErrorCode::PublishedForward);
 580                         }
 581                         /*
 582                          * All OK, set full definition
 583                          */
 584                         else
 585                         {
 586                             pForward->forwardDefined(*pInterface);
 587                             delete pInterface;
 588                             pInterface = pForward;
 589                         }
 590                     } else {
 591                         // special handling for XInterface because it is predefined
 592                         if ( pForward->isPredefined() &&
 593                              pForward->getScopedName() == "com::sun::star::uno::XInterface")
 594                         {
 595                             /* replace the predefined XInterface */
 596                             *pForward = *pInterface;
 597                             delete pInterface;
 598                             pInterface = pForward;
 599                         }
 600
 601                     }
 602                 }
 603             } else
 604             {
 605                 /*
 606                  * Add the interface to its definition scope
 607                  */
 608                 pScope->addDeclaration(pInterface);
 609             }
 610         }
 611         /*
 612          * Push it on the scope stack
 613          */
 614         idlc()->scopes()->push(pInterface);
 615         delete $1;
 616     }
 617     '{'
 618     {
 619         idlc()->setParseState(PS_InterfaceSqSeen);
 620     }
 621     exports
 622     {
 623         AstInterface * ifc = static_cast< AstInterface * >(
 624             idlc()->scopes()->topNonNull());
 625         if (!ifc->hasMandatoryInheritedInterfaces()
 626             && ifc->getScopedName() != "com::sun::star::uno::XInterface")
 627         {
 628             addInheritedInterface(
 629                 ifc, "::com::sun::star::uno::XInterface", false,
 630                 OUString());
 631         }
 632         ifc->setDefined();
 633         idlc()->setParseState(PS_InterfaceBodySeen);
 634     }
 635     '}'
 636     {
 637         idlc()->setParseState(PS_InterfaceQsSeen);
 638         /*
 639          * Done with this interface - pop it off the scopes stack
 640          */
 641         idlc()->scopes()->pop();
 642     }
 643     | error '}'
 644     {
 645         yyerror("interface definition");
 646         yyerrok;
 647     }
 648     ;
 649
 650 interfaceheader :
 651     interface_decl inheritance_spec
 652     {
 653         idlc()->setParseState(PS_InheritSpecSeen);
 654
 655         $$ = new FeInheritanceHeader(NT_interface, $1, $2, nullptr);
 656         delete $2;
 657     }
 658     ;
 659
 660 inheritance_spec :
 661     ':'
 662     {
 663         idlc()->setParseState(PS_InheritColonSeen);
 664     }
 665     scoped_name
 666     {
 667         $$ = $3;
 668     }
 669     | /* EMPTY */
 670     {
 671         $$ = nullptr;
 672     }
 673     ;
 674
 675 exports :
 676     exports export
 677     | /* EMPTY */
 678     ;
 679
 680 export :
 681     attribute
 682     {
 683         idlc()->setParseState(PS_AttributeDeclSeen);
 684     }
 685     ';'
 686     {
 687         idlc()->setParseState(PS_NoState);
 688     }
 689     | operation
 690     {
 691         idlc()->setParseState(PS_OperationDeclSeen);
 692     }
 693     ';'
 694     {
 695         idlc()->setParseState(PS_NoState);
 696     }
 697     | interface_inheritance_decl
 698     {
 699         idlc()->setParseState(PS_InterfaceInheritanceDeclSeen);
 700     }
 701     ';'
 702     {
 703         idlc()->setParseState(PS_NoState);
 704     }
 705     ;
 706
 707 attribute :
 708     flag_header
 709     simple_type_spec
 710     {
 711         idlc()->setParseState(PS_AttrTypeSeen);
 712     }
 713     declarator
 714     {
 715         idlc()->setParseState(PS_AttrCompleted);
 716         if (($1 & ~(AF_BOUND | AF_READONLY)) != AF_ATTRIBUTE) {
 717             ErrorHandler::flagError(ErrorCode::BadAttributeFlags, $1);
 718         }
 719         AstInterface * scope = static_cast< AstInterface * >(
 720             idlc()->scopes()->top());
 721         AstAttribute * attr = new AstAttribute(
 722             $1, FeDeclarator::compose($2), $4->getName(), scope);
 723         delete $4;
 724         AstInterface::DoubleMemberDeclarations doubleMembers(
 725             scope->checkMemberClashes(attr));
 726         if (doubleMembers.empty()) {
 727             scope->addMember(attr);
 728         } else {
 729             reportDoubleMemberDeclarations(doubleMembers);
 730         }
 731         idlc()->scopes()->push(attr);
 732     }
 733     opt_attribute_block
 734     {
 735         static_cast< AstAttribute * >(idlc()->scopes()->top())->setExceptions(
 736             $6.get.documentation, $6.get.exceptions, $6.set.documentation,
 737             $6.set.exceptions);
 738         delete $6.get.documentation;
 739         delete $6.get.exceptions;
 740         delete $6.set.documentation;
 741         delete $6.set.exceptions;
 742         idlc()->scopes()->pop();
 743     }
 744     ;
 745
 746 flag_header :
 747     '[' opt_attrflags ']'
 748     {
 749         idlc()->setParseState(PS_FlagHeaderSeen);
 750         $$ = $2;
 751     }
 752     ;
 753
 754 opt_attrflags :
 755     opt_attrflags ',' opt_attrflag
 756     {
 757         if ( ($1 & $3) == $3 )
 758             ErrorHandler::flagError(ErrorCode::DefinedAttributeFlag, $3);
 759
 760         $$ = $1 | $3;
 761     }
 762     | opt_attrflag
 763     {
 764         $$ = $1;
 765     }
 766     ;
 767
 768 opt_attrflag :
 769     IDL_ATTRIBUTE
 770     {
 771         idlc()->setParseState(PS_AttrSeen);
 772         $$ = AF_ATTRIBUTE;
 773     }
 774     | IDL_PROPERTY
 775     {
 776         idlc()->setParseState(PS_PropertySeen);
 777         $$ = AF_PROPERTY;
 778     }
 779     | IDL_READONLY
 780     {
 781         idlc()->setParseState(PS_ReadOnlySeen);
 782         $$ = AF_READONLY;
 783     }
 784     | IDL_OPTIONAL
 785     {
 786         idlc()->setParseState(PS_OptionalSeen);
 787         $$ = AF_OPTIONAL;
 788     }
 789     | IDL_MAYBEVOID
 790     {
 791         idlc()->setParseState(PS_MayBeVoidSeen);
 792         $$ = AF_MAYBEVOID;
 793     }
 794     | IDL_BOUND
 795     {
 796         idlc()->setParseState(PS_BoundSeen);
 797         $$ = AF_BOUND;
 798     }
 799     | IDL_CONSTRAINED
 800     {
 801         idlc()->setParseState(PS_ConstrainedSeen);
 802         $$ = AF_CONSTRAINED;
 803     }
 804     | IDL_TRANSIENT
 805     {
 806         idlc()->setParseState(PS_TransientSeen);
 807         $$ = AF_TRANSIENT;
 808     }
 809     | IDL_MAYBEAMBIGUOUS
 810     {
 811         idlc()->setParseState(PS_MayBeAmbigiousSeen);
 812         $$ = AF_MAYBEAMBIGUOUS;
 813     }
 814     | IDL_MAYBEDEFAULT
 815     {
 816         idlc()->setParseState(PS_MayBeDefaultSeen);
 817         $$ = AF_MAYBEDEFAULT;
 818     }
 819     | IDL_REMOVABLE
 820     {
 821         idlc()->setParseState(PS_RemoveableSeen);
 822         $$ = AF_REMOVABLE;
 823     }
 824     | error ']'
 825     {
 826         yyerror("unknown property|attribute flag");
 827         yyerrok;
 828     }
 829     ;
 830
 831 opt_attribute_block:
 832     '{' attribute_block_rest { $$ = $2; }
 833     | /* empty */
 834     {
 835         $$.get.documentation = nullptr;
 836         $$.get.exceptions = nullptr;
 837         $$.set.documentation = nullptr;
 838         $$.set.exceptions = nullptr;
 839     }
 840     ;
 841
 842 attribute_block_rest:
 843     opt_attribute_raises '}'
 844     | error '}'
 845     {
 846         yyerror("bad attribute raises block");
 847         yyerrok;
 848         $$.get.documentation = nullptr;
 849         $$.get.exceptions = nullptr;
 850         $$.set.documentation = nullptr;
 851         $$.set.exceptions = nullptr;
 852     }
 853     ;
 854
 855 opt_attribute_raises:
 856     attribute_get_raises
 857     opt_attribute_set_raises
 858     {
 859         $$.get = $1;
 860         $$.set = $2;
 861     }
 862     | attribute_set_raises
 863     opt_attribute_get_raises
 864     {
 865         $$.get = $2;
 866         $$.set = $1;
 867     }
 868     | /* empty */
 869     {
 870         $$.get.documentation = nullptr;
 871         $$.get.exceptions = nullptr;
 872         $$.set.documentation = nullptr;
 873         $$.set.exceptions = nullptr;
 874     }
 875     ;
 876
 877 opt_attribute_get_raises:
 878     attribute_get_raises
 879     | /* empty */ { $$.documentation = nullptr; $$.exceptions = nullptr; }
 880     ;
 881
 882 attribute_get_raises:
 883     IDL_GET raises ';'
 884     {
 885         $$.documentation = new OUString(
 886             OStringToOUString(
 887                 idlc()->getDocumentation(), RTL_TEXTENCODING_UTF8));
 888         $$.exceptions = $2;
 889     }
 890     ;
 891
 892 opt_attribute_set_raises:
 893     attribute_set_raises
 894     | /* empty */ { $$.documentation = nullptr; $$.exceptions = nullptr; }
 895     ;
 896
 897 attribute_set_raises:
 898     IDL_SET
 899     {
 900         if (static_cast< AstAttribute * >(idlc()->scopes()->top())->
 901             isReadonly())
 902         {
 903             ErrorHandler::error0(ErrorCode::ReadOnlyAttributeSetExceptions);
 904         }
 905     }
 906     raises ';'
 907     {
 908         $$.documentation = new OUString(
 909             OStringToOUString(
 910                 idlc()->getDocumentation(), RTL_TEXTENCODING_UTF8));
 911         $$.exceptions = $3;
 912     }
 913     ;
 914
 915 operation :
 916     op_type_spec
 917     {
 918         idlc()->setParseState(PS_OpTypeSeen);
 919     }
 920     identifier
 921     {
 922         idlc()->setParseState(PS_OpIDSeen);
 923         checkIdentifier($3);
 924
 925         AstInterface * pScope = static_cast< AstInterface * >(
 926             idlc()->scopes()->top());
 927         AstOperation*   pOp = nullptr;
 928
 929         /*
 930          * Create a node representing an operation on an interface
 931          * and add it to its enclosing scope
 932          */
 933         if ( pScope && $1 )
 934         {
 935             AstType const *pType = static_cast<AstType const *>($1);
 936             if ( !pType || (pType->getNodeType() == NT_exception) )
 937             {
 938                 // type ERROR
 939             } else
 940             {
 941                 pOp = new AstOperation(pType, *$3, pScope);
 942
 943                 AstInterface::DoubleMemberDeclarations doubleMembers(
 944                     pScope->checkMemberClashes(pOp));
 945                 if (doubleMembers.empty()) {
 946                     pScope->addMember(pOp);
 947                 } else {
 948                     reportDoubleMemberDeclarations(doubleMembers);
 949                 }
 950             }
 951         }
 952         delete $3;
 953         /*
 954          * Push the operation scope onto the scopes stack
 955          */
 956         idlc()->scopes()->push(pOp);
 957     }
 958     '('
 959     {
 960         idlc()->setParseState(PS_OpSqSeen);
 961     }
 962     parameters
 963     {
 964         idlc()->setParseState(PS_OpParsCompleted);
 965     }
 966     ')'
 967     {
 968         idlc()->setParseState(PS_OpQsSeen);
 969     }
 970     opt_raises
 971     {
 972         AstScope*       pScope = idlc()->scopes()->topNonNull();
 973         AstOperation*   pOp = nullptr;
 974         /*
 975          * Add exceptions and context to the operation
 976          */
 977         if ( pScope && pScope->getScopeNodeType() == NT_operation)
 978         {
 979             pOp = static_cast<AstOperation*>(pScope);
 980
 981             if ( pOp )
 982                 pOp->setExceptions($11);
 983         }
 984         delete $11;
 985         /*
 986          * Done with this operation. Pop its scope from the scopes stack
 987          */
 988         idlc()->scopes()->pop();
 989     }
 990     ;
 991
 992 op_type_spec :
 993     simple_type_spec
 994     | IDL_VOID
 995     {
 996         $$ = idlc()->scopes()->bottom()->lookupPrimitiveType(ET_void);
 997     }
 998     ;
 999
1000 parameters :
1001     parameter
1002     | parameters
1003     ','
1004     {
1005         idlc()->setParseState(PS_OpParCommaSeen);
1006     }
1007     parameter
1008     | /* EMPTY */
1009     | error ','
1010     {
1011         yyerror("parameter definition");
1012         yyerrok;
1013     }
1014     ;
1015
1016 parameter :
1017     '['
1018     direction
1019     ']'
1020     {
1021         idlc()->setParseState(PS_OpParDirSeen);
1022     }
1023     simple_type_spec
1024     {
1025         idlc()->setParseState(PS_OpParTypeSeen);
1026     }
1027     opt_rest
1028     declarator
1029     {
1030         idlc()->setParseState(PS_OpParDeclSeen);
1031
1032         AstOperation * pScope = static_cast< AstOperation * >(
1033             idlc()->scopes()->top());
1034         AstParameter*   pParam = nullptr;
1035
1036         /*
1037          * Create a node representing an argument to an operation
1038          * Add it to the enclosing scope (the operation scope)
1039          */
1040         if ( pScope && $5 && $8 )
1041         {
1042             AstType const * pType = FeDeclarator::compose($5);
1043             if ( pType )
1044             {
1045                 if (pScope->isConstructor() && $2 != DIR_IN) {
1046                     ErrorHandler::error0(ErrorCode::ConstructorParameterNotIn);
1047                 }
1048                 if (pScope->isVariadic()) {
1049                     ErrorHandler::error0(ErrorCode::RestParameterNotLast);
1050                 }
1051                 if ($7) {
1052                     AstDeclaration const * type = resolveTypedefs(pType);
1053                     if (type->getNodeType() != NT_predefined
1054                         || (static_cast< AstBaseType const * >(type)->
1055                             getExprType() != ET_any))
1056                     {
1057                         ErrorHandler::error0(ErrorCode::RestParameterNotAny);
1058                     }
1059                     if (pScope->isConstructor()) {
1060                         if (pScope->getIteratorBegin()
1061                             != pScope->getIteratorEnd())
1062                         {
1063                             ErrorHandler::error0(
1064                                 ErrorCode::ConstructorRestParameterNotFirst);
1065                         }
1066                     } else {
1067                         ErrorHandler::error0(ErrorCode::MethodHasRestParameter);
1068                     }
1069                 }
1070
1071                 pParam = new AstParameter(
1072                     static_cast< Direction >($2), $7, pType, $8->getName(),
1073                     pScope);
1074
1075                 if ( !$8->checkType($5) )
1076                 {
1077                     // WARNING
1078                 }
1079
1080                 pScope->addDeclaration(pParam);
1081             }
1082         }
1083     }
1084     | error
1085     simple_type_spec
1086     {
1087         idlc()->setParseState(PS_NoState);
1088         yyerrok;
1089     }
1090     ;
1091
1092 direction :
1093     IDL_IN
1094     {
1095         $$ = DIR_IN;
1096     }
1097     | IDL_OUT
1098     {
1099         $$ = DIR_OUT;
1100     }
1101     | IDL_INOUT
1102     {
1103         $$ = DIR_INOUT;
1104     }
1105     ;
1106
1107 opt_rest:
1108     IDL_ELLIPSIS
1109     {
1110         $$ = true;
1111     }
1112     | /* empty */
1113     {
1114         $$ = false;
1115     }
1116     ;
1117
1118 opt_raises:
1119     raises
1120     | /* empty */
1121     {
1122         $$ = nullptr;
1123     }
1124     ;
1125
1126 raises:
1127     IDL_RAISES
1128     {
1129         idlc()->setParseState(PS_RaiseSeen);
1130     }
1131     '('
1132     {
1133         idlc()->setParseState(PS_RaiseSqSeen);
1134     }
1135     exception_list
1136     ')'
1137     {
1138         idlc()->setParseState(PS_RaiseQsSeen);
1139         $$ = $5;
1140     }
1141     ;
1142
1143 exception_list:
1144     exception_name
1145     {
1146         $$ = new DeclList;
1147         $$->push_back($1);
1148     }
1149     | exception_list ',' exception_name
1150     {
1151         $1->push_back($3);
1152         $$ = $1;
1153     }
1154     ;
1155
1156 exception_name:
1157     scoped_name
1158     {
1159         // The topmost scope is either an AstOperation (for interface methods
1160         // and service constructors) or an AstAttribute (for interface
1161         // attributes), so look up exception names in the next-to-topmost scope:
1162         AstDeclaration * decl = idlc()->scopes()->nextToTop()->lookupByName(
1163             *$1);
1164         if (decl == nullptr) {
1165             ErrorHandler::lookupError(*$1);
1166         } else if (!ErrorHandler::checkPublished(decl)) {
1167             decl = nullptr;
1168         } else if (decl->getNodeType() != NT_exception) {
1169             ErrorHandler::error1(ErrorCode::IllegalRaises, decl);
1170             decl = nullptr;
1171         }
1172         delete $1;
1173         $$ = decl;
1174     }
1175     ;
1176
1177 interface_inheritance_decl:
1178     optional_inherited_interface
1179     IDL_INTERFACE
1180     {
1181         idlc()->setParseState(PS_ServiceIFHeadSeen);
1182     }
1183     scoped_name
1184     {
1185         AstInterface * ifc = static_cast< AstInterface * >(
1186             idlc()->scopes()->top());
1187         if (ifc->usesSingleInheritance()) {
1188             ErrorHandler::error0(ErrorCode::MixedInheritance);
1189         } else {
1190             addInheritedInterface(
1191                 ifc, *$4, $1,
1192                 OStringToOUString(
1193                     idlc()->getDocumentation(), RTL_TEXTENCODING_UTF8));
1194         }
1195         delete $4;
1196     }
1197     ;
1198
1199 optional_inherited_interface:
1200     '[' IDL_OPTIONAL ']' { $$ = true; }
1201     | /* EMPTY */ { $$ = false; }
1202     ;
1203
1204 constants_exports :
1205     constants_export constants_exports
1206     | /* EMPTY */
1207     ;
1208
1209 constants_export :
1210     IDL_CONST
1211     {
1212         idlc()->setParseState(PS_ConstSeen);
1213     }
1214     const_type
1215     {
1216         idlc()->setParseState(PS_ConstTypeSeen);
1217     }
1218     identifier
1219     {
1220         idlc()->setParseState(PS_ConstIDSeen);
1221         checkIdentifier($5);
1222     }
1223     '='
1224     {
1225         idlc()->setParseState(PS_ConstAssignSeen);
1226     }
1227     expression
1228     {
1229         idlc()->setParseState(PS_ConstExprSeen);
1230
1231         AstScope*       pScope = idlc()->scopes()->topNonNull();
1232         AstConstant*    pConstant = nullptr;
1233
1234         if ( $9 && pScope )
1235         {
1236             if ( !$9->coerce($3) )
1237             {
1238                 ErrorHandler::coercionError($9, $3);
1239             } else
1240             {
1241                 pConstant = new AstConstant($3, $9, *$5, pScope);
1242                 pScope->addDeclaration(pConstant);
1243             }
1244         }
1245         delete $5;
1246
1247         idlc()->setParseState(PS_ConstantDeclSeen);
1248     }
1249     ';' {};
1250     ;
1251
1252 constants_dcl :
1253     IDL_CONSTANTS
1254     {
1255         idlc()->setParseState(PS_ConstantsSeen);
1256     }
1257     identifier
1258     {
1259         idlc()->setParseState(PS_ConstantsIDSeen);
1260         checkIdentifier($3);
1261     }
1262     '{'
1263     {
1264         idlc()->setParseState(PS_ConstantsSqSeen);
1265
1266         AstScope*       pScope = idlc()->scopes()->topNonNull();
1267         AstConstants*   pConstants = nullptr;
1268
1269         if ( pScope )
1270         {
1271             pConstants = new AstConstants(*$3, pScope);
1272             if( AstDeclaration* pExists = pScope->lookupForAdd(pConstants) )
1273             {
1274                 pExists->setInMainfile(idlc()->isInMainFile());
1275                 delete(pConstants);
1276                 pConstants = static_cast<AstConstants*>(pExists);
1277             } else
1278             {
1279                 pScope->addDeclaration(pConstants);
1280             }
1281             idlc()->scopes()->push(pConstants);
1282         }
1283         delete $3;
1284     }
1285     constants_exports
1286     {
1287         idlc()->setParseState(PS_ConstantsBodySeen);
1288     }
1289     '}'
1290     {
1291         idlc()->setParseState(PS_ConstantsQsSeen);
1292         /*
1293          * Finished with this constants - pop it from the scope stack
1294          */
1295         idlc()->scopes()->pop();
1296     }
1297     ;
1298
1299 expression : const_expr ;
1300
1301 const_expr : or_expr ;
1302
1303 or_expr :
1304     xor_expr
1305     | or_expr '|' xor_expr
1306     {
1307         $$ = new AstExpression(ExprComb::Or, $1, $3);
1308     }
1309     ;
1310
1311 xor_expr :
1312     and_expr
1313     | xor_expr '^' and_expr
1314     {
1315         $$ = new AstExpression(ExprComb::Xor, $1, $3);
1316     }
1317     ;
1318
1319 and_expr :
1320     shift_expr
1321     | and_expr '&' shift_expr
1322     {
1323         $$ = new AstExpression(ExprComb::And, $1, $3);
1324     }
1325     ;
1326
1327 shift_expr :
1328     add_expr
1329     | shift_expr IDL_LEFTSHIFT add_expr
1330     {
1331         $$ = new AstExpression(ExprComb::Left, $1, $3);
1332     }
1333     | shift_expr IDL_RIGHTSHIFT add_expr
1334     {
1335         $$ = new AstExpression(ExprComb::Right, $1, $3);
1336     }
1337     ;
1338
1339 add_expr :
1340     mult_expr
1341     | add_expr '+' mult_expr
1342     {
1343         $$ = new AstExpression(ExprComb::Add, $1, $3);
1344     }
1345     | add_expr '-' mult_expr
1346     {
1347         $$ = new AstExpression(ExprComb::Minus, $1, $3);
1348     }
1349     ;
1350
1351 mult_expr :
1352     unary_expr
1353     | mult_expr '*' unary_expr
1354     {
1355         $$ = new AstExpression(ExprComb::Mul, $1, $3);
1356     }
1357     | mult_expr '/' unary_expr
1358     {
1359         $$ = new AstExpression(ExprComb::Div, $1, $3);
1360     }
1361     | mult_expr '%' unary_expr
1362     {
1363         $$ = new AstExpression(ExprComb::Mod, $1, $3);
1364     }
1365     ;
1366
1367 unary_expr :
1368     primary_expr
1369     | '+' primary_expr
1370     {
1371         $$ = new AstExpression(ExprComb::UPlus, $2, nullptr);
1372     }
1373     | '-' primary_expr
1374     {
1375         $$ = new AstExpression(ExprComb::UMinus, $2, nullptr);
1376     }
1377     | '~' primary_expr
1378     {
1379     }
1380     ;
1381
1382 primary_expr :
1383     scoped_name
1384     {
1385         /*
1386          * An expression which is a scoped name is not resolved now,
1387          * but only when it is evaluated (such as when it is assigned
1388          * as a constant value)
1389          */
1390         $$ = new AstExpression($1);
1391     }
1392     | literal
1393     | '(' const_expr ')'
1394     {
1395         $$ = $2;
1396     }
1397     ;
1398
1399 literal :
1400     IDL_INTEGER_LITERAL
1401     {
1402         $$ = new AstExpression($1);
1403     }
1404     | IDL_INTEGER_ULITERAL
1405     {
1406         $$ = new AstExpression($1);
1407     }
1408     | IDL_FLOATING_PT_LITERAL
1409     {
1410         $$ = new AstExpression($1);
1411     }
1412     | IDL_TRUE
1413     {
1414         $$ = new AstExpression(sal_Int32(1), ET_boolean);
1415     }
1416     | IDL_FALSE
1417     {
1418         $$ = new AstExpression(sal_Int32(0), ET_boolean);
1419     }
1420     ;
1421
1422 const_type :
1423     integer_type
1424     | byte_type
1425     | boolean_type
1426     | floating_pt_type
1427     | scoped_name
1428     {
1429         AstScope*       pScope = idlc()->scopes()->topNonNull();
1430         AstDeclaration const * type = nullptr;
1431
1432         /*
1433          * If the constant's type is a scoped name, it must resolve
1434          * to a scalar constant type
1435          */
1436         if ( pScope && (type = pScope->lookupByName(*$1)) ) {
1437             if (!ErrorHandler::checkPublished(type))
1438             {
1439                 type = nullptr;
1440                 $$ = ET_none;
1441             }
1442             else
1443             {
1444                 type = resolveTypedefs(type);
1445                 if (type->getNodeType() == NT_predefined)
1446                 {
1447                     $$ = static_cast< AstBaseType const * >(type)->
1448                         getExprType();
1449                 } else
1450                     $$ = ET_any;
1451             }
1452         } else
1453             $$ = ET_any;
1454     }
1455     ;
1456
1457 exception_header :
1458     IDL_EXCEPTION
1459     {
1460         idlc()->setParseState(PS_ExceptSeen);
1461     }
1462     identifier
1463     {
1464         idlc()->setParseState(PS_ExceptIDSeen);
1465         checkIdentifier($3);
1466     }
1467     inheritance_spec
1468     {
1469         idlc()->setParseState(PS_InheritSpecSeen);
1470
1471         $$ = new FeInheritanceHeader(NT_exception, $3, $5, nullptr);
1472         delete $5;
1473     }
1474     ;
1475
1476 exception_dcl :
1477     exception_header
1478     {
1479         idlc()->setParseState(PS_ExceptHeaderSeen);
1480
1481         AstScope*       pScope = idlc()->scopes()->topNonNull();
1482         AstException*   pExcept = nullptr;
1483
1484         if ( pScope )
1485         {
1486             AstException* pBase = static_cast< AstException* >(
1487                 $1->getInherits());
1488             pExcept = new AstException(*$1->getName(), pBase, pScope);
1489             pScope->addDeclaration(pExcept);
1490         }
1491         /*
1492          * Push the scope of the exception on the scopes stack
1493          */
1494         idlc()->scopes()->push(pExcept);
1495         delete $1;
1496     }
1497     '{'
1498     {
1499         idlc()->setParseState(PS_ExceptSqSeen);
1500     }
1501     members
1502     {
1503         idlc()->setParseState(PS_ExceptBodySeen);
1504     }
1505     '}'
1506     {
1507         idlc()->setParseState(PS_ExceptQsSeen);
1508         /* this exception is finished, pop its scope from the stack */
1509         idlc()->scopes()->pop();
1510     }
1511     ;
1512
1513 property :
1514     flag_header
1515     simple_type_spec
1516     {
1517         idlc()->setParseState(PS_PropertyTypeSeen);
1518     }
1519     at_least_one_declarator
1520     {
1521         idlc()->setParseState(PS_PropertyCompleted);
1522
1523         AstScope*       pScope = idlc()->scopes()->topNonNull();
1524         AstAttribute*   pAttr = nullptr;
1525         FeDeclList*     pList = $4;
1526         FeDeclarator*   pDecl = nullptr;
1527         AstType const * pType = nullptr;
1528
1529         if ( pScope->getScopeNodeType() == NT_singleton )
1530         {
1531             ErrorHandler::error0(ErrorCode::IllegalAdd);
1532         } else
1533         {
1534             if ( ($1 & AF_ATTRIBUTE) == AF_ATTRIBUTE )
1535                 ErrorHandler::flagError(ErrorCode::WrongAttributeKeyword, AF_ATTRIBUTE);
1536
1537             if ( ($1 & AF_PROPERTY) != AF_PROPERTY )
1538                 ErrorHandler::flagError(ErrorCode::MissingAttributeKeyword, AF_PROPERTY);
1539
1540             /*
1541              * Create nodes representing attributes and add them to the
1542              * enclosing scope
1543              */
1544             if ( pScope && $2 && pList )
1545             {
1546                 FeDeclList::iterator iter = pList->begin();
1547                 FeDeclList::iterator end = pList->end();
1548
1549                 while (iter != end)
1550                 {
1551                     pDecl = (*iter);
1552                     if ( !pDecl )
1553                     {
1554                         ++iter;
1555                         continue;
1556                     }
1557
1558                     pType = FeDeclarator::compose($2);
1559
1560                     if ( !pType )
1561                     {
1562                         ++iter;
1563                         continue;
1564                     }
1565
1566                     pAttr = new AstAttribute(NT_property, $1, pType, pDecl->getName(), pScope);
1567
1568                     pScope->addDeclaration(pAttr);
1569                     ++iter;
1570                     delete pDecl;
1571                 }
1572             }
1573         }
1574
1575         if ( pList )
1576             delete pList;
1577     }
1578     | error ';'
1579     {
1580         yyerror("property");
1581         yyerrok;
1582     }
1583     ;
1584
1585 service_exports :
1586     service_exports service_export
1587     | /* EMPTY */
1588     ;
1589
1590 service_export :
1591     service_interface_header
1592     at_least_one_scoped_name
1593     ';'
1594     {
1595         idlc()->setParseState(PS_ServiceMemberSeen);
1596
1597         AstScope*           pScope = idlc()->scopes()->topNonNull();
1598         AstDeclaration*     pDecl = nullptr;
1599         AstInterfaceMember* pIMember = nullptr;
1600
1601         if ( pScope->getScopeNodeType() == NT_singleton )
1602         {
1603             ErrorHandler::error0(ErrorCode::IllegalAdd);
1604         } else
1605         {
1606             /*
1607              * Create a node representing a class member.
1608              * Store it in the enclosing scope
1609              */
1610             if ( pScope && $2 )
1611             {
1612                 for (auto const& elem : *($2))
1613                 {
1614                     pDecl = pScope->lookupByName(elem);
1615                     if ( pDecl && (pDecl->getNodeType() == NT_interface) )
1616                     {
1617                         /* we relax the strict published check and allow to add new
1618                          * interfaces if they are optional
1619                          */
1620                         bool bOptional = (($1 & AF_OPTIONAL) == AF_OPTIONAL);
1621                         if ( ErrorHandler::checkPublished(pDecl, bOptional) )
1622                         {
1623                             pIMember = new AstInterfaceMember(
1624                                 $1, static_cast<AstInterface*>(pDecl), elem, pScope);
1625                             pScope->addDeclaration(pIMember);
1626                         }
1627                     } else
1628                     {
1629                         ErrorHandler::lookupError(ErrorCode::InterfaceMemberLookup, elem, scopeAsDecl(pScope));
1630                     }
1631                 }
1632             }
1633         }
1634         delete $2;
1635     }
1636     | service_service_header
1637     at_least_one_scoped_name
1638     ';'
1639     {
1640         idlc()->setParseState(PS_ServiceMemberSeen);
1641
1642         AstScope*         pScope = idlc()->scopes()->topNonNull();
1643         AstDeclaration*   pDecl = nullptr;
1644         AstServiceMember* pSMember = nullptr;
1645
1646         /*
1647          * Create a node representing a class member.
1648          * Store it in the enclosing scope
1649          */
1650         if ( pScope && $2 )
1651         {
1652             for (auto const& elem : *($2))
1653             {
1654                 pDecl = pScope->lookupByName(elem);
1655                 if ( pDecl && (pDecl->getNodeType() == NT_service) )
1656                 {
1657                     if ( static_cast< AstService * >(pDecl)->isSingleInterfaceBasedService() || (pScope->getScopeNodeType() == NT_singleton && pScope->nMembers() > 0) )
1658                         ErrorHandler::error0(ErrorCode::IllegalAdd);
1659                     else if ( ErrorHandler::checkPublished(pDecl) )
1660                     {
1661                         pSMember = new AstServiceMember(
1662                             $1, static_cast<AstService*>(pDecl), elem, pScope);
1663                         pScope->addDeclaration(pSMember);
1664                     }
1665                 } else
1666                 {
1667                     ErrorHandler::lookupError(ErrorCode::ServiceMemberLookup, elem, scopeAsDecl(pScope));
1668                 }
1669             }
1670         }
1671         delete $2;
1672     }
1673     | IDL_OBSERVES
1674     at_least_one_scoped_name
1675     ';'
1676     {
1677         idlc()->setParseState(PS_ServiceMemberSeen);
1678
1679         AstScope*       pScope = idlc()->scopes()->topNonNull();
1680         AstDeclaration* pDecl = nullptr;
1681         AstObserves*    pObserves = nullptr;
1682
1683         if ( pScope->getScopeNodeType() == NT_singleton )
1684         {
1685             ErrorHandler::error0(ErrorCode::IllegalAdd);
1686         } else
1687         {
1688             /*
1689              * Create a node representing a class member.
1690              * Store it in the enclosing scope
1691              */
1692             if ( pScope && $2 )
1693             {
1694                 for (auto const& elem : *($2))
1695                 {
1696                     pDecl = pScope->lookupByName(elem);
1697                     if ( pDecl && (pDecl->getNodeType() == NT_interface) )
1698                     {
1699                         pObserves = new AstObserves(static_cast<AstInterface*>(pDecl), elem, pScope);
1700                         pScope->addDeclaration(pObserves);
1701                     } else
1702                     {
1703                         ErrorHandler::lookupError(ErrorCode::InterfaceMemberLookup, elem, scopeAsDecl(pScope));
1704                     }
1705                 }
1706             }
1707         }
1708         delete $2;
1709     }
1710     | IDL_NEEDS
1711     at_least_one_scoped_name
1712     ';'
1713     {
1714         idlc()->setParseState(PS_ServiceMemberSeen);
1715
1716         AstScope*       pScope = idlc()->scopes()->topNonNull();
1717         AstDeclaration* pDecl = nullptr;
1718         AstNeeds*       pNeeds = nullptr;
1719
1720         if ( pScope->getScopeNodeType() == NT_singleton )
1721         {
1722             ErrorHandler::error0(ErrorCode::IllegalAdd);
1723         } else
1724         {
1725             /*
1726              * Create a node representing a class member.
1727              * Store it in the enclosing scope
1728              */
1729             if ( pScope && $2 )
1730             {
1731                 for (auto const& elem : *($2))
1732                 {
1733                     pDecl = pScope->lookupByName(elem);
1734                     if ( pDecl && (pDecl->getNodeType() == NT_service) )
1735                     {
1736                         pNeeds = new AstNeeds(static_cast<AstService*>(pDecl), elem, pScope);
1737                         pScope->addDeclaration(pNeeds);
1738                     } else
1739                     {
1740                         ErrorHandler::lookupError(ErrorCode::ServiceMemberLookup, elem, scopeAsDecl(pScope));
1741                     }
1742                 }
1743             }
1744         }
1745         delete $2;
1746     }
1747     | property
1748     ';'
1749     {
1750         idlc()->setParseState(PS_PropertyDeclSeen);
1751     }
1752     ;
1753
1754 service_interface_header :
1755     IDL_INTERFACE
1756     {
1757         idlc()->setParseState(PS_ServiceIFHeadSeen);
1758         $$ = AF_INVALID;
1759     }
1760     | flag_header
1761     IDL_INTERFACE
1762     {
1763         idlc()->setParseState(PS_ServiceIFHeadSeen);
1764         if ( (AF_OPTIONAL != $1) && ( AF_INVALID != $1) )
1765             ErrorHandler::flagError(ErrorCode::ExpectedOptional, $1);
1766         $$ = $1;
1767     }
1768     ;
1769
1770 service_service_header :
1771     IDL_SERVICE
1772     {
1773         idlc()->setParseState(PS_ServiceSHeadSeen);
1774         $$ = AF_INVALID;
1775     }
1776     | flag_header
1777     IDL_SERVICE
1778     {
1779         idlc()->setParseState(PS_ServiceSHeadSeen);
1780         if ( (AF_OPTIONAL != $1) && ( AF_INVALID != $1) )
1781             ErrorHandler::flagError(ErrorCode::ExpectedOptional, $1);
1782         $$ = $1;
1783     }
1784     ;
1785
1786 service_dcl :
1787     IDL_SERVICE
1788     {
1789         idlc()->setParseState(PS_ServiceSeen);
1790     }
1791     identifier
1792     {
1793         idlc()->setParseState(PS_ServiceIDSeen);
1794         checkIdentifier($3);
1795
1796         AstScope*   pScope = idlc()->scopes()->topNonNull();
1797         AstService* pService = nullptr;
1798
1799         /*
1800          * Make a new service and add it to the enclosing scope
1801          */
1802         if (pScope != nullptr)
1803         {
1804             pService = new AstService(*$3, pScope);
1805             pScope->addDeclaration(pService);
1806         }
1807         delete $3;
1808         /*
1809          * Push it on the stack
1810          */
1811         idlc()->scopes()->push(pService);
1812     }
1813     service_dfn
1814     {
1815         /* this service is finished, pop its scope from the stack */
1816         idlc()->scopes()->pop();
1817     }
1818     ;
1819
1820 service_dfn:
1821     service_interface_dfn
1822     | service_obsolete_dfn
1823     ;
1824
1825 service_interface_dfn:
1826     ':' scoped_name
1827     {
1828         AstScope * scope = idlc()->scopes()->nextToTop();
1829             // skip the scope pushed by service_dcl
1830         AstDeclaration * decl = scope->lookupByName(*$2);
1831         if (decl != nullptr
1832             && resolveTypedefs(decl)->getNodeType() == NT_interface)
1833         {
1834             if (ErrorHandler::checkPublished(decl)) {
1835                 idlc()->scopes()->top()->addDeclaration(decl);
1836             }
1837         } else {
1838             ErrorHandler::lookupError(
1839                 ErrorCode::InterfaceMemberLookup, *$2, scopeAsDecl(scope));
1840         }
1841         delete $2;
1842     }
1843     opt_service_body
1844     {
1845         AstService * s = static_cast< AstService * >(idlc()->scopes()->top());
1846         if (s != nullptr) {
1847             s->setSingleInterfaceBasedService();
1848             s->setDefaultConstructor(!$4);
1849         }
1850     }
1851     ;
1852
1853 opt_service_body:
1854     service_body { $$ = true; }
1855     | /* empty */ { $$ = false; }
1856     ;
1857
1858 service_body:
1859     '{'
1860     constructors
1861     '}'
1862     ;
1863
1864 constructors:
1865     constructors constructor
1866     | /* empty */
1867     ;
1868
1869 constructor:
1870     identifier
1871     {
1872         checkIdentifier($1);
1873         AstScope * scope = idlc()->scopes()->top();
1874         AstOperation * ctor = new AstOperation(nullptr, *$1, scope);
1875         delete $1;
1876         scope->addDeclaration(ctor);
1877         idlc()->scopes()->push(ctor);
1878     }
1879     '('
1880     parameters
1881     ')'
1882     opt_raises
1883     {
1884         static_cast< AstOperation * >(idlc()->scopes()->top())->setExceptions(
1885             $6);
1886         delete $6;
1887         idlc()->scopes()->pop();
1888         if (static_cast< AstService * >(idlc()->scopes()->top())->
1889             checkLastConstructor())
1890         {
1891             ErrorHandler::error0(ErrorCode::SimilarConstructors);
1892         }
1893     }
1894     ';'
1895     ;
1896
1897 singleton_dcl :
1898     IDL_SINGLETON
1899     {
1900         idlc()->setParseState(PS_SingletonSeen);
1901     }
1902     identifier
1903     {
1904         idlc()->setParseState(PS_SingletonIDSeen);
1905         checkIdentifier($3);
1906
1907         AstScope*   pScope = idlc()->scopes()->topNonNull();
1908         AstService* pService = nullptr;
1909
1910         /*
1911          * Make a new service and add it to the enclosing scope
1912          */
1913         if (pScope != nullptr)
1914         {
1915             pService = new AstService(NT_singleton, *$3, pScope);
1916             pScope->addDeclaration(pService);
1917         }
1918         delete $3;
1919         /*
1920          * Push it on the stack
1921          */
1922         idlc()->scopes()->push(pService);
1923     }
1924     singleton_dfn
1925     {
1926         /* this singelton is finished, pop its scope from the stack */
1927         idlc()->scopes()->pop();
1928     }
1929     ;
1930
1931 singleton_dfn:
1932     singleton_interface_dfn
1933     | service_obsolete_dfn
1934     ;
1935
1936 singleton_interface_dfn:
1937     ':' scoped_name
1938     {
1939         AstScope * scope = idlc()->scopes()->nextToTop();
1940             // skip the scope (needlessly) pushed by singleton_dcl
1941         AstDeclaration * decl = scope->lookupByName(*$2);
1942         if (decl != nullptr
1943             && resolveTypedefs(decl)->getNodeType() == NT_interface)
1944         {
1945             if (ErrorHandler::checkPublished(decl)) {
1946                 idlc()->scopes()->top()->addDeclaration(decl);
1947             }
1948         } else {
1949             ErrorHandler::lookupError(
1950                 ErrorCode::InterfaceMemberLookup, *$2, scopeAsDecl(scope));
1951         }
1952         delete $2;
1953     }
1954     ;
1955
1956 service_obsolete_dfn:
1957     '{'
1958     {
1959         idlc()->setParseState(
1960             idlc()->scopes()->top()->getScopeNodeType() == NT_service
1961             ? PS_ServiceSqSeen : PS_SingletonSqSeen);
1962     }
1963     service_exports
1964     {
1965         idlc()->setParseState(
1966             idlc()->scopes()->top()->getScopeNodeType() == NT_service
1967             ? PS_ServiceBodySeen : PS_SingletonBodySeen);
1968     }
1969     '}'
1970     {
1971         idlc()->setParseState(
1972             idlc()->scopes()->top()->getScopeNodeType() == NT_service
1973             ? PS_ServiceQsSeen : PS_SingletonQsSeen);
1974     }
1975     ;
1976
1977 type_dcl :
1978     IDL_TYPEDEF
1979     {
1980         idlc()->setParseState(PS_TypedefSeen);
1981     }
1982     type_declarator {}
1983     | struct_type {}
1984     | enum_type {}
1985     ;
1986
1987 type_declarator :
1988     type_spec
1989     {
1990         idlc()->setParseState(PS_TypeSpecSeen);
1991         if ($1 != nullptr && $1->getNodeType() == NT_instantiated_struct) {
1992             ErrorHandler::error0(ErrorCode::InstantiatedStructTypeTypedef);
1993         }
1994     }
1995     at_least_one_declarator
1996     {
1997         idlc()->setParseState(PS_DeclaratorsSeen);
1998
1999         AstScope*       pScope = idlc()->scopes()->topNonNull();
2000         AstTypeDef*     pTypeDef = nullptr;
2001         FeDeclList*     pList = $3;
2002         FeDeclarator*   pDecl = nullptr;
2003         AstType const * pType = nullptr;
2004
2005         /*
2006          * Create nodes representing typedefs and add them to the
2007          * enclosing scope
2008          */
2009         if ( pScope && $1 && pList )
2010         {
2011             FeDeclList::iterator iter = pList->begin();
2012             FeDeclList::iterator end = pList->end();
2013
2014             while (iter != end)
2015             {
2016                 pDecl = (*iter);
2017                 if ( !pDecl )
2018                 {
2019                     ++iter;
2020                     continue;
2021                 }
2022
2023                 pType = FeDeclarator::compose($1);
2024
2025                 if ( !pType )
2026                 {
2027                     ++iter;
2028                     continue;
2029                 }
2030
2031                 pTypeDef = new AstTypeDef(pType, pDecl->getName(), pScope);
2032
2033                 pScope->addDeclaration(pTypeDef);
2034                 ++iter;
2035                 delete pDecl;
2036             }
2037             delete pList;
2038         }
2039     }
2040     ;
2041
2042 at_least_one_declarator :
2043     declarator declarators
2044     {
2045         if ( $2 )
2046         {
2047             $2->push_back($1);
2048             $$ = $2;
2049         } else
2050         {
2051             FeDeclList* pList = new FeDeclList;
2052             pList->push_back($1);
2053             $$ = pList;
2054         }
2055     }
2056     ;
2057
2058 declarators :
2059     declarators
2060     ','
2061     {
2062         idlc()->setParseState(PS_DeclsCommaSeen);
2063     }
2064     declarator
2065     {
2066         idlc()->setParseState(PS_DeclsDeclSeen);
2067         if ( $1 )
2068         {
2069             $1->push_back($4);
2070             $$ = $1;
2071         } else
2072         {
2073             FeDeclList* pList = new FeDeclList;
2074             pList->push_back($4);
2075             $$ = pList;
2076         }
2077     }
2078     | /* EMPTY */
2079     {
2080         $$ = nullptr;
2081     }
2082     ;
2083
2084 declarator :
2085     identifier
2086     {
2087         // For historic reasons, the struct com.sun.star.uno.Uik contains
2088         // members with illegal names (of the form "m_DataN"); avoid useless
2089         // warnings about them:
2090         AstScope * scope = idlc()->scopes()->top();
2091         if (scope == nullptr || scope->getScopeNodeType() != NT_struct
2092             || (scopeAsDecl(scope)->getScopedName()
2093                 != "com::sun::star::uno::Uik"))
2094         {
2095             checkIdentifier($1);
2096         }
2097
2098         $$ = new FeDeclarator(*$1);
2099         delete $1;
2100     }
2101     ;
2102
2103 at_least_one_scoped_name :
2104     scoped_name scoped_names
2105     {
2106         if ($2)
2107         {
2108             $2->push_front(*$1);
2109             $$ = $2;
2110         } else
2111         {
2112             std::list< OString >* pScopedNames = new std::list< OString >;
2113             // coverity[copy_paste_error : FALSE] - this is not a cut and paste
2114             pScopedNames->push_back(*$1);
2115             $$ = pScopedNames;
2116         }
2117         delete $1;
2118     }
2119     ;
2120
2121 scoped_names :
2122     scoped_names
2123     ','
2124     {
2125         idlc()->setParseState(PS_SNListCommaSeen);
2126     }
2127     scoped_name
2128     {
2129         idlc()->setParseState(PS_ScopedNameSeen);
2130         if ($1)
2131         {
2132             $1->push_back(*$4);
2133             $$ = $1;
2134         } else
2135         {
2136             std::list< OString >* pNames = new std::list< OString >;
2137             pNames->push_back(*$4);
2138             $$ = pNames;
2139         }
2140         delete $4;
2141     }
2142     | /* EMPTY */
2143     {
2144         $$ = nullptr;
2145     }
2146     ;
2147
2148 scoped_name :
2149     identifier
2150     {
2151         idlc()->setParseState(PS_SN_IDSeen);
2152         checkIdentifier($1);
2153         $$ = $1;
2154     }
2155     | IDL_SCOPESEPARATOR
2156     {
2157         idlc()->setParseState(PS_ScopeDelimSeen);
2158     }
2159     identifier
2160     {
2161         checkIdentifier($3);
2162         OString* pName = new OString("::");
2163         *pName += *$3;
2164         delete $3;
2165         $$ = pName;
2166     }
2167     | scoped_name
2168     IDL_SCOPESEPARATOR
2169     {
2170     }
2171     identifier
2172     {
2173         checkIdentifier($4);
2174         *$1 += OString("::");
2175         *$1 += *$4;
2176         delete $4;
2177         $$ = $1;
2178     }
2179     ;
2180
2181 type_spec :
2182     simple_type_spec
2183     | constructed_type_spec
2184     ;
2185
2186 simple_type_spec :
2187     fundamental_type
2188     | scoped_name opt_type_args
2189     {
2190         $$ = createNamedType($1, $2);
2191     }
2192     ;
2193
2194 fundamental_type:
2195     base_type_spec
2196     {
2197         $$ = idlc()->scopes()->bottom()->lookupPrimitiveType($1);
2198     }
2199     | sequence_type_spec
2200     ;
2201
2202 opt_type_args:
2203     '<' type_args '>' { $$ = $2; }
2204     | /* empty */ { $$ = nullptr; }
2205     ;
2206
2207 type_args:
2208     type_arg
2209     {
2210         $$ = new DeclList;
2211         $$->push_back(const_cast< AstDeclaration * >($1)); //TODO: const_cast
2212     }
2213     | type_args ',' type_arg
2214     {
2215         $1->push_back(const_cast< AstDeclaration * >($3)); //TODO: const_cast
2216         $$ = $1;
2217     }
2218     ;
2219
2220 type_arg:
2221     simple_type_spec
2222     {
2223         if ($1 != nullptr && static_cast< AstType const * >($1)->isUnsigned()) {
2224             ErrorHandler::error0(ErrorCode::UnsignedTypeArgument);
2225         }
2226         $$ = $1;
2227     }
2228     ;
2229
2230 base_type_spec :
2231     integer_type
2232     | floating_pt_type
2233     | char_type
2234     | boolean_type
2235     | byte_type
2236     | any_type
2237     | type_type
2238     | string_type
2239     ;
2240
2241 integer_type :
2242     signed_int
2243     | unsigned_int
2244     ;
2245
2246 signed_int :
2247     IDL_LONG
2248     {
2249         $$ = ET_long;
2250     }
2251     | IDL_HYPER
2252     {
2253         $$ = ET_hyper;
2254     }
2255     | IDL_SHORT
2256     {
2257         $$ = ET_short;
2258     }
2259     ;
2260
2261 unsigned_int :
2262     IDL_UNSIGNED IDL_LONG
2263     {
2264         $$ = ET_ulong;
2265     }
2266     | IDL_UNSIGNED IDL_HYPER
2267     {
2268         $$ = ET_uhyper;
2269     }
2270     | IDL_UNSIGNED IDL_SHORT
2271     {
2272         $$ = ET_ushort;
2273     }
2274     ;
2275
2276 floating_pt_type :
2277     IDL_DOUBLE
2278     {
2279         $$ = ET_double;
2280     }
2281     | IDL_FLOAT
2282     {
2283         $$ = ET_float;
2284     }
2285     ;
2286
2287 char_type :
2288     IDL_CHAR
2289     {
2290         $$ = ET_char;
2291     }
2292     ;
2293
2294 byte_type :
2295     IDL_BYTE
2296     {
2297         $$ = ET_byte;
2298     }
2299     ;
2300
2301 boolean_type :
2302     IDL_BOOLEAN
2303     {
2304         $$ = ET_boolean;
2305     }
2306     ;
2307
2308 any_type :
2309     IDL_ANY
2310     {
2311         $$ = ET_any;
2312     }
2313     ;
2314
2315 type_type :
2316     IDL_TYPE
2317     {
2318         $$ = ET_type;
2319     }
2320     ;
2321
2322 string_type :
2323     IDL_STRING
2324     {
2325         $$ = ET_string;
2326     }
2327     ;
2328
2329 constructed_type_spec :
2330     struct_type
2331     | enum_type
2332     ;
2333
2334 sequence_type_spec :
2335     IDL_SEQUENCE
2336     {
2337         idlc()->setParseState(PS_SequenceSeen);
2338         /*
2339          * Push a sequence marker on scopes stack
2340          */
2341         idlc()->scopes()->push(nullptr);
2342     }
2343     '<'
2344     {
2345         idlc()->setParseState(PS_SequenceSqSeen);
2346     }
2347     simple_type_spec
2348     {
2349         idlc()->setParseState(PS_SequenceTypeSeen);
2350     }
2351     '>'
2352     {
2353         idlc()->setParseState(PS_SequenceQsSeen);
2354         /*
2355          * Remove sequence marker from scopes stack
2356          */
2357         if (idlc()->scopes()->top() == nullptr)
2358             idlc()->scopes()->pop();
2359         /*
2360          * Create a node representing a sequence
2361          */
2362         AstScope* pScope = idlc()->scopes()->bottom();
2363         AstDeclaration* pDecl = nullptr;
2364         AstDeclaration* pSeq = nullptr;
2365
2366         if ( $5 )
2367         {
2368             AstType const *pType = static_cast<AstType const *>($5);
2369             if ( pType )
2370             {
2371                 pSeq = new AstSequence(pType, pScope);
2372                 /*
2373                  * Add this AstSequence to the types defined in the global scope
2374                  */
2375                 pDecl = pScope->addDeclaration(pSeq);
2376                 if ( pSeq != pDecl )
2377                 {
2378                     // if sequence type already defined then use it
2379                     delete pSeq;
2380                     pSeq = pDecl;
2381                 }
2382             }
2383         }
2384         $$ = pSeq;
2385     }
2386     | error '>'
2387     {
2388         yyerror("sequence declaration");
2389         yyerrok;
2390         $$ = nullptr;
2391     }
2392     ;
2393
2394 struct_type :
2395     structure_header
2396     {
2397         idlc()->setParseState(PS_StructHeaderSeen);
2398
2399         AstScope*   pScope = idlc()->scopes()->topNonNull();
2400         AstStruct*  pStruct = nullptr;
2401
2402         if ( pScope )
2403         {
2404             AstStruct const* pBase= static_cast< AstStruct const* >(resolveTypedefs($1->getInherits()));
2405             pStruct = new AstStruct(
2406                 *$1->getName(), $1->getTypeParameters(), pBase, pScope);
2407             pScope->addDeclaration(pStruct);
2408         }
2409         /*
2410          * Push the scope of the struct on the scopes stack
2411          */
2412         idlc()->scopes()->push(pStruct);
2413         delete $1;
2414     }
2415     '{'
2416     {
2417         idlc()->setParseState(PS_StructSqSeen);
2418     }
2419     at_least_one_member
2420     {
2421         idlc()->setParseState(PS_StructBodySeen);
2422     }
2423     '}'
2424     {
2425         idlc()->setParseState(PS_StructQsSeen);
2426         /* this exception is finished, pop its scope from the stack */
2427         idlc()->scopes()->pop();
2428     }
2429     ;
2430
2431 structure_header :
2432     IDL_STRUCT
2433     {
2434         idlc()->setParseState(PS_StructSeen);
2435     }
2436     identifier
2437     {
2438         idlc()->setParseState(PS_StructIDSeen);
2439         checkIdentifier($3);
2440     }
2441     opt_type_params
2442     inheritance_spec
2443     {
2444         idlc()->setParseState(PS_InheritSpecSeen);
2445
2446         // Polymorphic struct type templates with base types would cause various
2447         // problems in language bindings, so forbid them here.  For example,
2448         // GCC prior to version 3.4 fails with code like
2449         //
2450         //  struct Base { ... };
2451         //  template< typename typeparam_T > struct Derived: public Base {
2452         //      int member1 CPPU_GCC3_ALIGN(Base);
2453         //      ... };
2454         //
2455         // (Note that plain struct types with instantiated polymorphic struct
2456         // type bases, which might also cause problems in language bindings, are
2457         // already rejected on a syntactic level.)
2458         if ($5 != nullptr && $6 != nullptr) {
2459             ErrorHandler::error0(ErrorCode::StructTypeTemplateWithBase);
2460         }
2461
2462         $$ = new FeInheritanceHeader(NT_struct, $3, $6, $5);
2463         delete $5;
2464         delete $6;
2465     }
2466     ;
2467
2468 opt_type_params:
2469     '<' type_params '>' { $$ = $2; }
2470     | /* empty */ { $$ = nullptr; }
2471     ;
2472
2473 type_params:
2474     identifier
2475     {
2476         $$ = new std::vector< OString >;
2477         $$->push_back(*$1);
2478         delete $1;
2479     }
2480     | type_params ',' identifier
2481     {
2482         if (std::find($1->begin(), $1->end(), *$3) != $1->end()) {
2483             ErrorHandler::error0(ErrorCode::IdenticalTypeParameters);
2484         }
2485         $1->push_back(*$3);
2486         delete $3;
2487         $$ = $1;
2488     }
2489     ;
2490
2491 at_least_one_member : member members ;
2492
2493 members :
2494     members member
2495     | /* EMPTY */
2496     ;
2497
2498 member :
2499     type_or_parameter
2500     {
2501         idlc()->setParseState(PS_MemberTypeSeen);
2502     }
2503     at_least_one_declarator
2504     {
2505         idlc()->setParseState(PS_MemberDeclsSeen);
2506     }
2507     ';'
2508     {
2509         idlc()->setParseState(PS_MemberDeclsCompleted);
2510
2511         AstScope*       pScope = idlc()->scopes()->topNonNull();
2512         AstMember*      pMember = nullptr;
2513         FeDeclList*     pList = $3;
2514         FeDeclarator*   pDecl = nullptr;
2515         AstType const * pType = nullptr;
2516
2517         // !!! check recursive type
2518
2519         if ( pScope && pList && $1 )
2520         {
2521             FeDeclList::iterator iter = pList->begin();
2522             FeDeclList::iterator end = pList->end();
2523             while (iter != end)
2524             {
2525                 pDecl = (*iter);
2526                 if ( !pDecl )
2527                 {
2528                     ++iter;
2529                     continue;
2530                 }
2531
2532                 pType = FeDeclarator::compose($1);
2533
2534                 if ( !pType )
2535                 {
2536                     ++iter;
2537                     continue;
2538                 }
2539
2540                 pMember = new AstMember(pType, pDecl->getName(), pScope);
2541
2542                 if ( !pDecl->checkType($1) )
2543                 {
2544                     // WARNING
2545                 }
2546
2547                 pScope->addDeclaration(pMember);
2548                 ++iter;
2549                 delete pDecl;
2550             }
2551             delete pList;
2552         }
2553     }
2554     | error ';'
2555     {
2556         yyerror("member definition");
2557         yyerrok;
2558     }
2559     ;
2560
2561 type_or_parameter:
2562     fundamental_type
2563     | scoped_name opt_type_args
2564     {
2565         AstDeclaration const * decl = nullptr;
2566         AstStruct * scope = static_cast< AstStruct * >(idlc()->scopes()->top());
2567         if (scope != nullptr && $2 == nullptr) {
2568             decl = scope->findTypeParameter(*$1);
2569         }
2570         if (decl != nullptr) {
2571             delete $1;
2572             delete $2;
2573         } else {
2574             decl = createNamedType($1, $2);
2575             if (scope != nullptr && includes(decl, scopeAsDecl(scope))) {
2576                 ErrorHandler::error1(
2577                     ErrorCode::RecursiveType, scopeAsDecl(scope));
2578                 decl = nullptr;
2579             }
2580         }
2581         $$ = decl;
2582     }
2583     ;
2584
2585 enum_type :
2586     IDL_ENUM
2587     {
2588         idlc()->setParseState(PS_EnumSeen);
2589     }
2590     identifier
2591     {
2592         idlc()->setParseState(PS_EnumIDSeen);
2593         checkIdentifier($3);
2594
2595         AstScope*       pScope = idlc()->scopes()->topNonNull();
2596         AstEnum*        pEnum = nullptr;
2597
2598         /*
2599          * Create a node representing an enum and add it to its
2600          * enclosing scope
2601          */
2602         if (pScope != nullptr)
2603         {
2604             pEnum = new AstEnum(*$3, pScope);
2605             /*
2606              * Add it to its defining scope
2607              */
2608             pScope->addDeclaration(pEnum);
2609         }
2610         delete $3;
2611         /*
2612          * Push the enum scope on the scopes stack
2613          */
2614         idlc()->scopes()->push(pEnum);
2615
2616     }
2617     '{'
2618     {
2619         idlc()->setParseState(PS_EnumSqSeen);
2620     }
2621     at_least_one_enumerator
2622     {
2623         idlc()->setParseState(PS_EnumBodySeen);
2624     }
2625     '}'
2626     {
2627         idlc()->setParseState(PS_EnumQsSeen);
2628         /*
2629          * Done with this enum. Pop its scope from the scopes stack
2630          */
2631         if (idlc()->scopes()->top() == nullptr)
2632             $$ = nullptr;
2633         else
2634         {
2635             $$ = static_cast<AstEnum*>(idlc()->scopes()->topNonNull());
2636             idlc()->scopes()->pop();
2637         }
2638     }
2639     ;
2640
2641 at_least_one_enumerator : enumerator enumerators ;
2642
2643 enumerators :
2644     enumerators
2645     ','
2646     {
2647         idlc()->setParseState(PS_EnumCommaSeen);
2648     }
2649     enumerator
2650     | /* EMPTY */
2651     | error ','
2652     {
2653         yyerror("enumerator definition");
2654         yyerrok;
2655     }
2656     ;
2657
2658 enumerator :
2659     identifier
2660     {
2661         checkIdentifier($1);
2662
2663         AstScope*       pScope = idlc()->scopes()->topNonNull();
2664         AstEnum*        pEnum = nullptr;
2665         AstConstant*    pEnumVal = nullptr;
2666
2667         if ( pScope && pScope->getScopeNodeType() == NT_enum)
2668         {
2669             pEnum = static_cast<AstEnum*>(pScope);
2670             if (pEnum && $1)
2671             {
2672                 AstExpression* pExpr = new AstExpression(pEnum->getEnumValueCount());
2673                 pEnumVal = new AstConstant(ET_long , NT_enum_val,
2674                                            pExpr, *$1, pScope);
2675             }
2676             if ( pEnum->checkValue(pEnumVal->getConstValue()) )
2677                 ErrorHandler::error1(ErrorCode::Eval, pEnum);
2678
2679             pScope->addDeclaration(pEnumVal);
2680         }
2681         delete $1;
2682     }
2683     | identifier
2684     '='
2685     const_expr
2686     {
2687         checkIdentifier($1);
2688
2689         AstScope*       pScope = idlc()->scopes()->topNonNull();
2690         AstEnum*        pEnum = nullptr;
2691         AstConstant*    pEnumVal = nullptr;
2692
2693         if ( $3 && pScope && pScope->getScopeNodeType() == NT_enum)
2694         {
2695             $3->evaluate();
2696             if ( $3->coerce(ET_long) )
2697             {
2698                 pEnum = static_cast<AstEnum*>(pScope);
2699                 if (pEnum)
2700                 {
2701                     pEnumVal = new AstConstant(ET_long , NT_enum_val,
2702                                                $3, *$1, pScope);
2703                 }
2704                 if ( pEnum->checkValue(pEnumVal->getConstValue()) )
2705                     ErrorHandler::error1(ErrorCode::Eval, pEnum);
2706
2707                 pScope->addDeclaration(pEnumVal);
2708             } else
2709             {
2710                 ErrorHandler::coercionError($3, ET_long);
2711                 delete $3;
2712             }
2713         }
2714         delete $1;
2715     }
2716     ;
2717
2718 identifier:
2719     IDL_IDENTIFIER
2720     | IDL_GET { $$ = new OString("get"); }
2721     | IDL_SET { $$ = new OString("set"); }
2722     | IDL_PUBLISHED { $$ = new OString("published"); }
2723     ;
2724
2725 %%
2726
2727 /*
2728  * Report an error situation discovered in a production
2729  */
2730 void yyerror(char const *errmsg)
2731 {
2732     ErrorHandler::syntaxError(idlc()->getParseState(), idlc()->getLineNumber(), errmsg);
2733     idlc()->setParseState(PS_NoState);
2734 }
2735
2736 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */