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