| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| /* |
| * parser.yy - BISON grammar for IDLC 1.0 |
| */ |
| |
| %{ |
| #include <string.h> |
| |
| #ifndef _IDLC_IDLC_HXX_ |
| #include <idlc/idlc.hxx> |
| #endif |
| #ifndef _IDLC_ERRORHANDLER_HXX_ |
| #include <idlc/errorhandler.hxx> |
| #endif |
| #ifndef _IDLC_FEHELPER_HXX_ |
| #include <idlc/fehelper.hxx> |
| #endif |
| #ifndef _IDLC_EXPRESSION_HXX_ |
| #include <idlc/astexpression.hxx> |
| #endif |
| #ifndef _IDLC_ASTCONSTANTS_HXX_ |
| #include <idlc/astconstants.hxx> |
| #endif |
| #ifndef _IDLC_ASTCONSTANT_HXX_ |
| #include <idlc/astconstant.hxx> |
| #endif |
| #ifndef _IDLC_ASTARRAY_HXX_ |
| #include <idlc/astarray.hxx> |
| #endif |
| #ifndef _IDLC_ASTBASETYPE_HXX_ |
| #include <idlc/astbasetype.hxx> |
| #endif |
| #ifndef _IDLC_ASTTYPEDEF_HXX_ |
| #include <idlc/asttypedef.hxx> |
| #endif |
| #ifndef _IDLC_ASTEXCEPTION_HXX_ |
| #include <idlc/astexception.hxx> |
| #endif |
| #ifndef _IDLC_ASTMEMBER_HXX_ |
| #include <idlc/astmember.hxx> |
| #endif |
| #ifndef _IDLC_ASTENUM_HXX_ |
| #include <idlc/astenum.hxx> |
| #endif |
| #ifndef _IDLC_ASTSEQUENCE_HXX_ |
| #include <idlc/astsequence.hxx> |
| #endif |
| #ifndef _IDLC_ASTATTRIBUTE_HXX_ |
| #include <idlc/astattribute.hxx> |
| #endif |
| #ifndef _IDLC_ASTOPERATION_HXX_ |
| #include <idlc/astoperation.hxx> |
| #endif |
| #ifndef _IDLC_ASTPARAMETER_HXX_ |
| #include <idlc/astparameter.hxx> |
| #endif |
| #ifndef _IDLC_ASTINTERFACEMEMBER_HXX_ |
| #include <idlc/astinterfacemember.hxx> |
| #endif |
| #ifndef _IDLC_ASTSERVICEMEMBER_HXX_ |
| #include <idlc/astservicemember.hxx> |
| #endif |
| #ifndef _IDLC_ASTOBSERVES_HXX_ |
| #include <idlc/astobserves.hxx> |
| #endif |
| #ifndef _IDLC_ASTNEEDS_HXX_ |
| #include <idlc/astneeds.hxx> |
| #endif |
| #ifndef _IDLC_ASTUNION_HXX_ |
| #include <idlc/astunion.hxx> |
| #endif |
| #include "idlc/aststructinstance.hxx" |
| |
| #include "attributeexceptions.hxx" |
| |
| #include "rtl/strbuf.hxx" |
| |
| #include <algorithm> |
| #include <vector> |
| |
| using namespace ::rtl; |
| |
| #define YYDEBUG 1 |
| #define YYERROR_VERBOSE 1 |
| |
| extern int yylex(void); |
| void yyerror(char const *); |
| |
| void checkIdentifier(::rtl::OString* id) |
| { |
| static short check = 0; |
| if (check == 0) { |
| if (idlc()->getOptions()->isValid("-cid")) |
| check = 1; |
| else |
| check = 2; |
| } |
| |
| if ( id->indexOf('_') >= 0 ) |
| if ( (id->pData->buffer[0] >= 97 && id->pData->buffer[0] <= 122) |
| || id->pData->buffer[0] == '_') { |
| if (check == 1) { |
| ::rtl::OStringBuffer msg(25 + id->getLength()); |
| msg.append("mismatched identifier '"); |
| msg.append(*id); |
| msg.append("'"); |
| idlc()->error()->syntaxError(idlc()->getParseState(), |
| idlc()->getLineNumber(), |
| msg.getStr()); |
| } |
| else |
| idlc()->error()->warning0(WIDL_WRONG_NAMING_CONV, id->getStr()); |
| } |
| } |
| |
| void reportDoubleMemberDeclarations( |
| AstInterface::DoubleMemberDeclarations const & doubleMembers) |
| { |
| for (AstInterface::DoubleMemberDeclarations::const_iterator i( |
| doubleMembers.begin()); |
| i != doubleMembers.end(); ++i) |
| { |
| idlc()->error()->error2(EIDL_DOUBLE_MEMBER, i->first, i->second); |
| } |
| } |
| |
| void addInheritedInterface( |
| AstInterface * ifc, rtl::OString const & name, bool optional, |
| rtl::OUString const & documentation) |
| { |
| AstDeclaration * decl = ifc->lookupByName(name); |
| AstDeclaration const * resolved = resolveTypedefs(decl); |
| if (resolved != 0 && resolved->getNodeType() == NT_interface) { |
| if (idlc()->error()->checkPublished(decl)) { |
| if (!static_cast< AstInterface const * >(resolved)->isDefined()) { |
| idlc()->error()->inheritanceError( |
| NT_interface, &ifc->getScopedName(), decl); |
| } else { |
| AstInterface::DoubleDeclarations doubleDecls( |
| ifc->checkInheritedInterfaceClashes( |
| static_cast< AstInterface const * >(resolved), |
| optional)); |
| if (doubleDecls.interfaces.empty() |
| && doubleDecls.members.empty()) |
| { |
| ifc->addInheritedInterface( |
| static_cast< AstType * >(decl), optional, |
| documentation); |
| } else { |
| for (AstInterface::DoubleInterfaceDeclarations::iterator i( |
| doubleDecls.interfaces.begin()); |
| i != doubleDecls.interfaces.end(); ++i) |
| { |
| idlc()->error()->error1( |
| EIDL_DOUBLE_INHERITANCE, *i); |
| } |
| reportDoubleMemberDeclarations(doubleDecls.members); |
| } |
| } |
| } |
| } else { |
| idlc()->error()->lookupError( |
| EIDL_INTERFACEMEMBER_LOOKUP, name, scopeAsDecl(ifc)); |
| } |
| } |
| |
| AstDeclaration const * createNamedType( |
| rtl::OString const * scopedName, DeclList const * typeArgs) |
| { |
| AstDeclaration * decl = idlc()->scopes()->topNonNull()->lookupByName( |
| *scopedName); |
| AstDeclaration const * resolved = resolveTypedefs(decl); |
| if (decl == 0) { |
| idlc()->error()->lookupError(*scopedName); |
| } else if (!idlc()->error()->checkPublished(decl)) { |
| decl = 0; |
| } else if (resolved->getNodeType() == NT_struct) { |
| if (static_cast< AstStruct const * >(resolved)->getTypeParameterCount() |
| != (typeArgs == 0 ? 0 : typeArgs->size())) |
| { |
| idlc()->error()->error0(EIDL_WRONG_NUMBER_OF_TYPE_ARGUMENTS); |
| decl = 0; |
| } else if (typeArgs != 0) { |
| AstScope * global = idlc()->scopes()->bottom(); |
| AstDeclaration * inst = new AstStructInstance( |
| static_cast< AstType * >(decl), typeArgs, global); |
| decl = global->addDeclaration(inst); |
| if (decl != inst) { |
| delete inst; |
| } |
| } |
| } else if (decl->isType()) { |
| if (typeArgs != 0) { |
| idlc()->error()->error0(EIDL_WRONG_NUMBER_OF_TYPE_ARGUMENTS); |
| decl = 0; |
| } |
| } else { |
| idlc()->error()->noTypeError(decl); |
| decl = 0; |
| } |
| delete scopedName; |
| delete typeArgs; |
| return decl; |
| } |
| |
| bool includes(AstDeclaration const * type1, AstDeclaration const * type2) { |
| OSL_ASSERT(type2 != 0); |
| if (type1 != 0) { |
| if (type1->getNodeType() == NT_instantiated_struct) { |
| AstStructInstance const * inst |
| = static_cast< AstStructInstance const * >(type1); |
| if (inst->getTypeTemplate() == type2) { |
| return true; |
| } |
| for (DeclList::const_iterator i(inst->getTypeArgumentsBegin()); |
| i != inst->getTypeArgumentsEnd(); ++i) |
| { |
| if (includes(*i, type2)) { |
| return true; |
| } |
| } |
| } else if (type1 == type2) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| // Suppress any warnings from generated code: |
| #if defined __GNUC__ |
| #pragma GCC system_header |
| #elif defined __SUNPRO_CC |
| #pragma disable_warn |
| #elif defined _MSC_VER |
| #pragma warning(push, 1) |
| #pragma warning(disable: 4273 4701 4706) |
| #endif |
| %} |
| /* |
| * Declare the type of values in the grammar |
| */ |
| %union { |
| ExprType etval; /* Expression type */ |
| AstDeclaration* dclval; /* Declaration */ |
| AstDeclaration const * cdclval; |
| DeclList * dclsval; |
| AstExpression* exval; /* expression value */ |
| ExprList* exlval; /* expression list value */ |
| FeDeclarator* fdval; /* declarator value */ |
| FeDeclList* dlval; /* declarator list value */ |
| FeInheritanceHeader* ihval; /* inheritance header value */ |
| ::rtl::OString* sval; /* OString value */ |
| std::vector< rtl::OString > * svals; |
| sal_Char* strval; /* sal_Char* value */ |
| sal_Bool bval; /* sal_Boolean* value */ |
| sal_Int64 ival; /* sal_Int64 value */ |
| sal_uInt64 uval; /* sal_uInt64 value */ |
| sal_uInt32 ulval; /* sal_uInt32 value */ |
| double dval; /* double value */ |
| float fval; /* float value */ |
| StringList* slval; /* StringList value */ |
| LabelList* llval; /* LabelList value */ |
| AstUnionLabel* lbval; /* union label value */ |
| AstMember* mval; /* member value */ |
| AttributeExceptions::Part attexcpval; |
| AttributeExceptions attexcval; |
| } |
| |
| /* |
| * Token types: These are returned by the lexer |
| */ |
| |
| %token <sval> IDL_IDENTIFIER |
| %token IDL_ATTRIBUTE |
| %token IDL_BOUND |
| %token IDL_CASE |
| %token IDL_CONST |
| %token IDL_CONSTANTS |
| %token IDL_CONSTRAINED |
| %token IDL_DEFAULT |
| %token IDL_ENUM |
| %token IDL_EXCEPTION |
| %token IDL_INTERFACE |
| %token IDL_MAYBEAMBIGUOUS |
| %token IDL_MAYBEDEFAULT |
| %token IDL_MAYBEVOID |
| %token IDL_MODULE |
| %token IDL_NEEDS |
| %token IDL_OBSERVES |
| %token IDL_OPTIONAL |
| %token IDL_PROPERTY |
| %token IDL_RAISES |
| %token IDL_READONLY |
| %token IDL_REMOVEABLE |
| %token IDL_SERVICE |
| %token IDL_SEQUENCE |
| %token IDL_SINGLETON |
| %token IDL_STRUCT |
| %token IDL_SWITCH |
| %token IDL_TYPEDEF |
| %token IDL_TRANSIENT |
| %token IDL_UNION |
| |
| %token IDL_ANY |
| %token IDL_CHAR |
| %token IDL_BOOLEAN |
| %token IDL_BYTE |
| %token IDL_DOUBLE |
| %token IDL_FLOAT |
| %token IDL_HYPER |
| %token IDL_LONG |
| %token IDL_SHORT |
| %token IDL_VOID |
| %token IDL_STRING |
| %token IDL_TYPE |
| %token IDL_UNSIGNED |
| |
| %token IDL_TRUE |
| %token IDL_FALSE |
| |
| %token IDL_IN |
| %token IDL_OUT |
| %token IDL_INOUT |
| %token IDL_ONEWAY |
| |
| %token IDL_GET |
| %token IDL_SET |
| |
| %token IDL_PUBLISHED |
| |
| %token IDL_ELLIPSIS |
| |
| %token <strval> IDL_LEFTSHIFT |
| %token <strval> IDL_RIGHTSHIFT |
| %token <strval> IDL_SCOPESEPARATOR |
| |
| %token <ival> IDL_INTEGER_LITERAL |
| %token <uval> IDL_INTEGER_ULITERAL |
| %token <dval> IDL_FLOATING_PT_LITERAL |
| |
| /* |
| * These are production names: |
| */ |
| %type <dclval> type_dcl const_dcl |
| %type <dclval> array_declarator |
| %type <dclval> exception_name |
| %type <cdclval> array_type constructed_type_spec enum_type op_type_spec |
| %type <cdclval> sequence_type_spec simple_type_spec struct_type switch_type_spec |
| %type <cdclval> template_type_spec type_spec union_type |
| %type <cdclval> fundamental_type type_arg type_or_parameter |
| %type <dclsval> opt_raises raises exception_list |
| %type <attexcpval> opt_attribute_get_raises attribute_get_raises |
| %type <attexcpval> opt_attribute_set_raises attribute_set_raises |
| %type <dclsval> opt_type_args type_args |
| |
| %type <sval> identifier |
| %type <sval> interface_decl |
| %type <sval> scoped_name inheritance_spec |
| %type <slval> scoped_names at_least_one_scoped_name |
| |
| %type <etval> const_type integer_type char_type boolean_type |
| %type <etval> floating_pt_type any_type signed_int string_type |
| %type <etval> unsigned_int base_type_spec byte_type type_type |
| |
| %type <exval> expression const_expr or_expr xor_expr and_expr |
| %type <exval> add_expr mult_expr unary_expr primary_expr shift_expr |
| %type <exval> literal positive_int_expr array_dim |
| |
| %type <exlval> at_least_one_array_dim array_dims |
| |
| %type <fdval> declarator simple_declarator complex_declarator |
| %type <dlval> declarators at_least_one_declarator |
| |
| %type <ihval> exception_header structure_header interfaceheader |
| |
| %type <ulval> flag_header opt_attrflags opt_attrflag operation_head |
| %type <ulval> direction service_interface_header service_service_header |
| |
| %type <llval> case_labels at_least_one_case_label |
| %type <lbval> case_label |
| %type <mval> element_spec |
| |
| %type <bval> optional_inherited_interface opt_rest opt_service_body |
| |
| %type <attexcval> opt_attribute_block attribute_block_rest opt_attribute_raises |
| |
| %type <svals> opt_type_params type_params |
| |
| %% |
| /* |
| * Grammar start here |
| */ |
| start : definitions; |
| |
| definitions : |
| definition definitions |
| | /* EMPTY */ |
| ; |
| |
| definition : |
| opt_published publishable_definition |
| | module_dcl |
| { |
| idlc()->setParseState(PS_ModuleDeclSeen); |
| } |
| ';' |
| { |
| idlc()->setParseState(PS_NoState); |
| } |
| | error ';' |
| { |
| yyerror("definitions"); |
| yyerrok; |
| } |
| ; |
| |
| opt_published: |
| IDL_PUBLISHED { idlc()->setPublished(true); } |
| | /* empty */ { idlc()->setPublished(false); } |
| ; |
| |
| publishable_definition: |
| type_dcl |
| { |
| idlc()->setParseState(PS_TypeDeclSeen); |
| } |
| ';' |
| { |
| idlc()->setParseState(PS_NoState); |
| } |
| | const_dcl |
| { |
| idlc()->setParseState(PS_ConstantDeclSeen); |
| } |
| ';' |
| { |
| idlc()->setParseState(PS_NoState); |
| } |
| | exception_dcl |
| { |
| idlc()->setParseState(PS_ExceptionDeclSeen); |
| } |
| ';' |
| { |
| idlc()->setParseState(PS_NoState); |
| } |
| | interface |
| { |
| idlc()->setParseState(PS_InterfaceDeclSeen); |
| } |
| ';' |
| { |
| idlc()->setParseState(PS_NoState); |
| } |
| | service_dcl |
| { |
| idlc()->setParseState(PS_ServiceDeclSeen); |
| } |
| ';' |
| { |
| idlc()->setParseState(PS_NoState); |
| } |
| | singleton_dcl |
| { |
| idlc()->setParseState(PS_SingletonDeclSeen); |
| } |
| ';' |
| { |
| idlc()->setParseState(PS_NoState); |
| } |
| | constants_dcl |
| { |
| idlc()->setParseState(PS_ConstantsDeclSeen); |
| } |
| ';' |
| { |
| idlc()->setParseState(PS_NoState); |
| } |
| ; |
| |
| module_dcl : |
| IDL_MODULE |
| { |
| idlc()->setParseState(PS_ModuleSeen); |
| idlc()->setPublished(false); |
| } |
| identifier |
| { |
| idlc()->setParseState(PS_ModuleIDSeen); |
| checkIdentifier($3); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstModule* pModule = NULL; |
| AstDeclaration* pExists = NULL; |
| |
| if ( pScope ) |
| { |
| pModule = new AstModule(*$3, pScope); |
| if( (pExists = pScope->lookupForAdd(pModule)) ) |
| { |
| pExists->setInMainfile(idlc()->isInMainFile()); |
| pExists->setFileName(pModule->getFileName()); |
| if (pExists->isPredefined()) |
| { |
| pExists->setPredefined(false); |
| if (pExists->getDocumentation().getLength() == 0 && |
| pModule->getDocumentation().getLength() > 0) |
| { |
| pExists->setDocumentation(pModule->getDocumentation()); |
| } |
| } |
| delete(pModule); |
| pModule = (AstModule*)pExists; |
| } else |
| { |
| pScope->addDeclaration(pModule); |
| } |
| idlc()->scopes()->push(pModule); |
| } |
| delete $3; |
| } |
| '{' |
| { |
| idlc()->setParseState(PS_ModuleSqSeen); |
| } |
| definitions |
| { |
| idlc()->setParseState(PS_ModuleBodySeen); |
| } |
| '}' |
| { |
| idlc()->setParseState(PS_ModuleQsSeen); |
| /* |
| * Finished with this module - pop it from the scope stack |
| */ |
| idlc()->scopes()->pop(); |
| } |
| ; |
| |
| interface : |
| interface_dcl |
| | forward_dcl |
| ; |
| |
| interface_decl : |
| IDL_INTERFACE |
| { |
| idlc()->setParseState(PS_InterfaceSeen); |
| } |
| identifier |
| { |
| idlc()->setParseState(PS_InterfaceIDSeen); |
| checkIdentifier($3); |
| $$ = $3; |
| } |
| ; |
| |
| forward_dcl : |
| interface_decl |
| { |
| idlc()->setParseState(PS_ForwardDeclSeen); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstInterface* pForward = NULL; |
| AstDeclaration* pDecl = NULL; |
| |
| /* |
| * Make a new forward interface node and add it to its enclosing scope |
| */ |
| if ( pScope && $1 ) |
| { |
| pForward = new AstInterface(*$1, NULL, pScope); |
| |
| if ( pDecl = pScope->lookupByName(pForward->getScopedName()) ) |
| { |
| if ( (pDecl != pForward) && |
| (pDecl->getNodeType() == NT_interface) ) |
| { |
| delete pForward; |
| } else |
| { |
| idlc()->error()->error2(EIDL_REDEF_SCOPE, scopeAsDecl(pScope), pDecl); |
| } |
| } else |
| { |
| /* |
| * Add the interface to its definition scope |
| */ |
| pScope->addDeclaration(pForward); |
| } |
| } |
| delete $1; |
| } |
| ; |
| |
| interface_dcl : |
| interfaceheader |
| { |
| idlc()->setParseState(PS_InterfaceHeadSeen); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstInterface* pInterface = NULL; |
| AstInterface* pForward = NULL; |
| AstDeclaration* pDecl = NULL; |
| |
| /* |
| * Make a new interface node and add it to its enclosing scope |
| */ |
| if ( pScope && $1 ) |
| { |
| pInterface = new AstInterface( |
| *$1->getName(), |
| static_cast< AstInterface * >($1->getInherits()), pScope); |
| if ( pInterface && |
| (pDecl = pScope->lookupByName(pInterface->getScopedName())) ) |
| { |
| /* |
| * See if we're defining a forward declared interface. |
| */ |
| if (pDecl->getNodeType() == NT_interface) |
| { |
| pForward = (AstInterface*)pDecl; |
| if ( !pForward->isDefined() ) |
| { |
| /* |
| * Check if redefining in same scope |
| */ |
| if ( pForward->getScope() != pScope ) |
| { |
| if ( pForward->getScopedName() != pInterface->getScopedName() ) |
| { |
| idlc()->error()->error3(EIDL_SCOPE_CONFLICT, |
| pInterface, pForward, scopeAsDecl(pScope)); |
| } |
| } |
| else if ( !pInterface->isPublished() |
| && pForward->isPublished() ) |
| { |
| idlc()->error()->error0(EIDL_PUBLISHED_FORWARD); |
| } |
| /* |
| * All OK, set full definition |
| */ |
| else |
| { |
| pForward->forwardDefined(*pInterface); |
| delete pInterface; |
| pInterface = pForward; |
| } |
| } else { |
| // special handling for XInterface because it is predefined |
| if ( pForward->isPredefined() && |
| pForward->getScopedName() == "com::sun::star::uno::XInterface") |
| { |
| /* replace the predefined XInterface */ |
| *pForward = *pInterface; |
| delete pInterface; |
| pInterface = pForward; |
| } |
| |
| } |
| } |
| } else |
| { |
| /* |
| * Add the interface to its definition scope |
| */ |
| pScope->addDeclaration(pInterface); |
| } |
| } |
| /* |
| * Push it on the scope stack |
| */ |
| idlc()->scopes()->push(pInterface); |
| delete($1); |
| } |
| '{' |
| { |
| idlc()->setParseState(PS_InterfaceSqSeen); |
| } |
| exports |
| { |
| AstInterface * ifc = static_cast< AstInterface * >( |
| idlc()->scopes()->topNonNull()); |
| if (!ifc->hasMandatoryInheritedInterfaces() |
| && ifc->getScopedName() != "com::sun::star::uno::XInterface") |
| { |
| addInheritedInterface( |
| ifc, rtl::OString("::com::sun::star::uno::XInterface"), false, |
| rtl::OUString()); |
| } |
| ifc->setDefined(); |
| idlc()->setParseState(PS_InterfaceBodySeen); |
| } |
| '}' |
| { |
| idlc()->setParseState(PS_InterfaceQsSeen); |
| /* |
| * Done with this interface - pop it off the scopes stack |
| */ |
| idlc()->scopes()->pop(); |
| } |
| | error '}' |
| { |
| yyerror("interface definition"); |
| yyerrok; |
| } |
| ; |
| |
| interfaceheader : |
| interface_decl inheritance_spec |
| { |
| idlc()->setParseState(PS_InheritSpecSeen); |
| |
| $$ = new FeInheritanceHeader(NT_interface, $1, $2, 0); |
| delete $2; |
| } |
| ; |
| |
| inheritance_spec : |
| ':' |
| { |
| idlc()->setParseState(PS_InheritColonSeen); |
| } |
| scoped_name |
| { |
| $$ = $3; |
| } |
| | /* EMPTY */ |
| { |
| $$ = NULL; |
| } |
| ; |
| |
| exports : |
| exports export |
| | /* EMPTY */ |
| ; |
| |
| export : |
| attribute |
| { |
| idlc()->setParseState(PS_AttributeDeclSeen); |
| } |
| ';' |
| { |
| idlc()->setParseState(PS_NoState); |
| } |
| | operation |
| { |
| idlc()->setParseState(PS_OperationDeclSeen); |
| } |
| ';' |
| { |
| idlc()->setParseState(PS_NoState); |
| } |
| | interface_inheritance_decl |
| { |
| idlc()->setParseState(PS_InterfaceInheritanceDeclSeen); |
| } |
| ';' |
| { |
| idlc()->setParseState(PS_NoState); |
| } |
| ; |
| |
| attribute : |
| flag_header |
| simple_type_spec |
| { |
| idlc()->setParseState(PS_AttrTypeSeen); |
| } |
| simple_declarator |
| { |
| idlc()->setParseState(PS_AttrCompleted); |
| if (($1 & ~(AF_BOUND | AF_READONLY)) != AF_ATTRIBUTE) { |
| idlc()->error()->flagError(EIDL_BAD_ATTRIBUTE_FLAGS, $1); |
| } |
| AstInterface * scope = static_cast< AstInterface * >( |
| idlc()->scopes()->top()); |
| AstAttribute * attr = new AstAttribute( |
| $1, $4->compose($2), $4->getName(), scope); |
| delete $4; |
| AstInterface::DoubleMemberDeclarations doubleMembers( |
| scope->checkMemberClashes(attr)); |
| if (doubleMembers.empty()) { |
| scope->addMember(attr); |
| } else { |
| reportDoubleMemberDeclarations(doubleMembers); |
| } |
| idlc()->scopes()->push(attr); |
| } |
| opt_attribute_block |
| { |
| static_cast< AstAttribute * >(idlc()->scopes()->top())->setExceptions( |
| $6.get.documentation, $6.get.exceptions, $6.set.documentation, |
| $6.set.exceptions); |
| delete $6.get.documentation; |
| delete $6.get.exceptions; |
| delete $6.set.documentation; |
| delete $6.set.exceptions; |
| idlc()->scopes()->pop(); |
| } |
| ; |
| |
| flag_header : |
| '[' opt_attrflags ']' |
| { |
| idlc()->setParseState(PS_FlagHeaderSeen); |
| $$ = $2; |
| } |
| ; |
| |
| opt_attrflags : |
| opt_attrflags ',' opt_attrflag |
| { |
| if ( ($1 & $3) == $3 ) |
| idlc()->error()->flagError(EIDL_DEFINED_ATTRIBUTEFLAG, $3); |
| |
| $$ = $1 | $3; |
| } |
| | opt_attrflag |
| { |
| $$ = $1; |
| } |
| ; |
| |
| opt_attrflag : |
| IDL_ATTRIBUTE |
| { |
| idlc()->setParseState(PS_AttrSeen); |
| $$ = AF_ATTRIBUTE; |
| } |
| | IDL_PROPERTY |
| { |
| idlc()->setParseState(PS_PropertySeen); |
| $$ = AF_PROPERTY; |
| } |
| | IDL_READONLY |
| { |
| idlc()->setParseState(PS_ReadOnlySeen); |
| $$ = AF_READONLY; |
| } |
| | IDL_OPTIONAL |
| { |
| idlc()->setParseState(PS_OptionalSeen); |
| $$ = AF_OPTIONAL; |
| } |
| | IDL_MAYBEVOID |
| { |
| idlc()->setParseState(PS_MayBeVoidSeen); |
| $$ = AF_MAYBEVOID; |
| } |
| | IDL_BOUND |
| { |
| idlc()->setParseState(PS_BoundSeen); |
| $$ = AF_BOUND; |
| } |
| | IDL_CONSTRAINED |
| { |
| idlc()->setParseState(PS_ConstrainedSeen); |
| $$ = AF_CONSTRAINED; |
| } |
| | IDL_TRANSIENT |
| { |
| idlc()->setParseState(PS_TransientSeen); |
| $$ = AF_TRANSIENT; |
| } |
| | IDL_MAYBEAMBIGUOUS |
| { |
| idlc()->setParseState(PS_MayBeAmbigiousSeen); |
| $$ = AF_MAYBEAMBIGUOUS; |
| } |
| | IDL_MAYBEDEFAULT |
| { |
| idlc()->setParseState(PS_MayBeDefaultSeen); |
| $$ = AF_MAYBEDEFAULT; |
| } |
| | IDL_REMOVEABLE |
| { |
| idlc()->setParseState(PS_RemoveableSeen); |
| $$ = AF_REMOVEABLE; |
| } |
| | error ']' |
| { |
| yyerror("unknown property|attribute flag"); |
| yyerrok; |
| } |
| ; |
| |
| opt_attribute_block: |
| '{' attribute_block_rest { $$ = $2; } |
| | /* empty */ |
| { |
| $$.get.documentation = 0; |
| $$.get.exceptions = 0; |
| $$.set.documentation = 0; |
| $$.set.exceptions = 0; |
| } |
| ; |
| |
| attribute_block_rest: |
| opt_attribute_raises '}' |
| | error '}' |
| { |
| yyerror("bad attribute raises block"); |
| yyerrok; |
| $$.get.documentation = 0; |
| $$.get.exceptions = 0; |
| $$.set.documentation = 0; |
| $$.set.exceptions = 0; |
| } |
| ; |
| |
| opt_attribute_raises: |
| attribute_get_raises |
| opt_attribute_set_raises |
| { |
| $$.get = $1; |
| $$.set = $2; |
| } |
| | attribute_set_raises |
| opt_attribute_get_raises |
| { |
| $$.get = $2; |
| $$.set = $1; |
| } |
| | /* empty */ |
| { |
| $$.get.documentation = 0; |
| $$.get.exceptions = 0; |
| $$.set.documentation = 0; |
| $$.set.exceptions = 0; |
| } |
| ; |
| |
| opt_attribute_get_raises: |
| attribute_get_raises |
| | /* empty */ { $$.documentation = 0; $$.exceptions = 0; } |
| ; |
| |
| attribute_get_raises: |
| IDL_GET raises ';' |
| { |
| $$.documentation = new rtl::OUString( |
| rtl::OStringToOUString( |
| idlc()->getDocumentation(), RTL_TEXTENCODING_UTF8)); |
| $$.exceptions = $2; |
| } |
| ; |
| |
| opt_attribute_set_raises: |
| attribute_set_raises |
| | /* empty */ { $$.documentation = 0; $$.exceptions = 0; } |
| ; |
| |
| attribute_set_raises: |
| IDL_SET |
| { |
| if (static_cast< AstAttribute * >(idlc()->scopes()->top())-> |
| isReadonly()) |
| { |
| idlc()->error()->error0(EIDL_READONLY_ATTRIBUTE_SET_EXCEPTIONS); |
| } |
| } |
| raises ';' |
| { |
| $$.documentation = new rtl::OUString( |
| rtl::OStringToOUString( |
| idlc()->getDocumentation(), RTL_TEXTENCODING_UTF8)); |
| $$.exceptions = $3; |
| } |
| ; |
| |
| operation : |
| operation_head |
| op_type_spec |
| { |
| idlc()->setParseState(PS_OpTypeSeen); |
| } |
| identifier |
| { |
| idlc()->setParseState(PS_OpIDSeen); |
| checkIdentifier($4); |
| |
| AstInterface * pScope = static_cast< AstInterface * >( |
| idlc()->scopes()->top()); |
| AstOperation* pOp = NULL; |
| |
| /* |
| * Create a node representing an operation on an interface |
| * and add it to its enclosing scope |
| */ |
| if ( pScope && $2 ) |
| { |
| AstType *pType = (AstType*)$2; |
| if ( !pType || (pType->getNodeType() == NT_exception) ) |
| { |
| // type ERROR |
| } else |
| { |
| pOp = new AstOperation($1, pType, *$4, pScope); |
| |
| AstInterface::DoubleMemberDeclarations doubleMembers( |
| pScope->checkMemberClashes(pOp)); |
| if (doubleMembers.empty()) { |
| pScope->addMember(pOp); |
| } else { |
| reportDoubleMemberDeclarations(doubleMembers); |
| } |
| } |
| } |
| delete $4; |
| /* |
| * Push the operation scope onto the scopes stack |
| */ |
| idlc()->scopes()->push(pOp); |
| } |
| '(' |
| { |
| idlc()->setParseState(PS_OpSqSeen); |
| } |
| parameters |
| { |
| idlc()->setParseState(PS_OpParsCompleted); |
| } |
| ')' |
| { |
| idlc()->setParseState(PS_OpQsSeen); |
| } |
| opt_raises |
| { |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstOperation* pOp = NULL; |
| /* |
| * Add exceptions and context to the operation |
| */ |
| if ( pScope && pScope->getScopeNodeType() == NT_operation) |
| { |
| pOp = (AstOperation*)pScope; |
| |
| if ( pOp ) |
| pOp->setExceptions($12); |
| } |
| delete $12; |
| /* |
| * Done with this operation. Pop its scope from the scopes stack |
| */ |
| idlc()->scopes()->pop(); |
| } |
| ; |
| |
| operation_head : |
| '[' |
| IDL_ONEWAY |
| { |
| idlc()->setParseState(PS_OpOnewaySeen); |
| } |
| ']' |
| { |
| idlc()->setParseState(PS_OpHeadSeen); |
| $$ = OP_ONEWAY; |
| } |
| | /* EMPTY */ |
| { |
| $$ = OP_NONE; |
| } |
| ; |
| |
| op_type_spec : |
| simple_type_spec |
| | IDL_VOID |
| { |
| $$ = idlc()->scopes()->bottom()->lookupPrimitiveType(ET_void); |
| } |
| ; |
| |
| parameters : |
| parameter |
| | parameters |
| ',' |
| { |
| idlc()->setParseState(PS_OpParCommaSeen); |
| } |
| parameter |
| | /* EMPTY */ |
| | error ',' |
| { |
| yyerror("parameter definition"); |
| yyerrok; |
| } |
| ; |
| |
| parameter : |
| '[' |
| direction |
| ']' |
| { |
| idlc()->setParseState(PS_OpParDirSeen); |
| } |
| simple_type_spec |
| { |
| idlc()->setParseState(PS_OpParTypeSeen); |
| } |
| opt_rest |
| declarator |
| { |
| idlc()->setParseState(PS_OpParDeclSeen); |
| |
| AstOperation * pScope = static_cast< AstOperation * >( |
| idlc()->scopes()->top()); |
| AstParameter* pParam = NULL; |
| |
| /* |
| * Create a node representing an argument to an operation |
| * Add it to the enclosing scope (the operation scope) |
| */ |
| if ( pScope && $5 && $8 ) |
| { |
| AstType const * pType = $8->compose($5); |
| if ( pType ) |
| { |
| if (pScope->isConstructor() && $2 != DIR_IN) { |
| idlc()->error()->error0(EIDL_CONSTRUCTOR_PARAMETER_NOT_IN); |
| } |
| if (pScope->isVariadic()) { |
| idlc()->error()->error0(EIDL_REST_PARAMETER_NOT_LAST); |
| } |
| if ($7) { |
| AstDeclaration const * type = resolveTypedefs(pType); |
| if (type->getNodeType() != NT_predefined |
| || (static_cast< AstBaseType const * >(type)-> |
| getExprType() != ET_any)) |
| { |
| idlc()->error()->error0(EIDL_REST_PARAMETER_NOT_ANY); |
| } |
| if (pScope->isConstructor()) { |
| if (pScope->getIteratorBegin() |
| != pScope->getIteratorEnd()) |
| { |
| idlc()->error()->error0( |
| EIDL_CONSTRUCTOR_REST_PARAMETER_NOT_FIRST); |
| } |
| } else { |
| idlc()->error()->error0(EIDL_METHOD_HAS_REST_PARAMETER); |
| } |
| } |
| |
| pParam = new AstParameter( |
| static_cast< Direction >($2), $7, pType, $8->getName(), |
| pScope); |
| |
| if ( !$8->checkType($5) ) |
| { |
| // WARNING |
| } |
| |
| pScope->addDeclaration(pParam); |
| } |
| } |
| } |
| | error |
| simple_type_spec |
| { |
| idlc()->setParseState(PS_NoState); |
| yyerrok; |
| } |
| ; |
| |
| direction : |
| IDL_IN |
| { |
| $$ = DIR_IN; |
| } |
| | IDL_OUT |
| { |
| $$ = DIR_OUT; |
| } |
| | IDL_INOUT |
| { |
| $$ = DIR_INOUT; |
| } |
| ; |
| |
| opt_rest: |
| IDL_ELLIPSIS |
| { |
| $$ = true; |
| } |
| | /* empty */ |
| { |
| $$ = false; |
| } |
| ; |
| |
| opt_raises: |
| raises |
| | /* empty */ |
| { |
| $$ = 0; |
| } |
| ; |
| |
| raises: |
| IDL_RAISES |
| { |
| idlc()->setParseState(PS_RaiseSeen); |
| } |
| '(' |
| { |
| idlc()->setParseState(PS_RaiseSqSeen); |
| } |
| exception_list |
| ')' |
| { |
| idlc()->setParseState(PS_RaiseQsSeen); |
| $$ = $5; |
| } |
| ; |
| |
| exception_list: |
| exception_name |
| { |
| $$ = new DeclList; |
| $$->push_back($1); |
| } |
| | exception_list ',' exception_name |
| { |
| $1->push_back($3); |
| $$ = $1; |
| } |
| ; |
| |
| exception_name: |
| scoped_name |
| { |
| // The topmost scope is either an AstOperation (for interface methods |
| // and service constructors) or an AstAttribute (for interface |
| // attributes), so look up exception names in the next-to-topmost scope: |
| AstDeclaration * decl = idlc()->scopes()->nextToTop()->lookupByName( |
| *$1); |
| if (decl == 0) { |
| idlc()->error()->lookupError(*$1); |
| } else if (!idlc()->error()->checkPublished(decl)) { |
| decl = 0; |
| } else if (decl->getNodeType() != NT_exception) { |
| idlc()->error()->error1(EIDL_ILLEGAL_RAISES, decl); |
| decl = 0; |
| } |
| delete $1; |
| $$ = decl; |
| } |
| ; |
| |
| interface_inheritance_decl: |
| optional_inherited_interface |
| IDL_INTERFACE |
| { |
| idlc()->setParseState(PS_ServiceIFHeadSeen); |
| } |
| scoped_name |
| { |
| AstInterface * ifc = static_cast< AstInterface * >( |
| idlc()->scopes()->top()); |
| if (ifc->usesSingleInheritance()) { |
| idlc()->error()->error0(EIDL_MIXED_INHERITANCE); |
| } else { |
| addInheritedInterface( |
| ifc, *$4, $1, |
| rtl::OStringToOUString( |
| idlc()->getDocumentation(), RTL_TEXTENCODING_UTF8)); |
| } |
| delete $4; |
| } |
| ; |
| |
| optional_inherited_interface: |
| '[' IDL_OPTIONAL ']' { $$ = true; } |
| | /* EMPTY */ { $$ = false; } |
| ; |
| |
| constants_exports : |
| constants_export constants_exports |
| | /* EMPTY */ |
| ; |
| |
| constants_export : |
| const_dcl |
| { |
| idlc()->setParseState(PS_ConstantDeclSeen); |
| } |
| ';' {}; |
| |
| const_dcl : |
| IDL_CONST |
| { |
| idlc()->setParseState(PS_ConstSeen); |
| } |
| const_type |
| { |
| idlc()->setParseState(PS_ConstTypeSeen); |
| } |
| identifier |
| { |
| idlc()->setParseState(PS_ConstIDSeen); |
| checkIdentifier($5); |
| } |
| '=' |
| { |
| idlc()->setParseState(PS_ConstAssignSeen); |
| } |
| expression |
| { |
| idlc()->setParseState(PS_ConstExprSeen); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstConstant* pConstant = NULL; |
| |
| if ( $9 && pScope ) |
| { |
| if ( !$9->coerce($3) ) |
| { |
| idlc()->error()->coercionError($9, $3); |
| } else |
| { |
| pConstant = new AstConstant($3, $9, *$5, pScope); |
| pScope->addDeclaration(pConstant); |
| } |
| } |
| delete $5; |
| } |
| ; |
| |
| constants_dcl : |
| IDL_CONSTANTS |
| { |
| idlc()->setParseState(PS_ConstantsSeen); |
| } |
| identifier |
| { |
| idlc()->setParseState(PS_ConstantsIDSeen); |
| checkIdentifier($3); |
| } |
| '{' |
| { |
| idlc()->setParseState(PS_ConstantsSqSeen); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstConstants* pConstants = NULL; |
| AstDeclaration* pExists = NULL; |
| |
| if ( pScope ) |
| { |
| pConstants = new AstConstants(*$3, pScope); |
| if( (pExists = pScope->lookupForAdd(pConstants)) ) |
| { |
| pExists->setInMainfile(idlc()->isInMainFile()); |
| delete(pConstants); |
| pConstants = (AstConstants*)pExists; |
| } else |
| { |
| pScope->addDeclaration(pConstants); |
| } |
| idlc()->scopes()->push(pConstants); |
| } |
| delete $3; |
| } |
| constants_exports |
| { |
| idlc()->setParseState(PS_ConstantsBodySeen); |
| } |
| '}' |
| { |
| idlc()->setParseState(PS_ConstantsQsSeen); |
| /* |
| * Finished with this constants - pop it from the scope stack |
| */ |
| idlc()->scopes()->pop(); |
| } |
| ; |
| |
| expression : const_expr ; |
| |
| const_expr : or_expr ; |
| |
| or_expr : |
| xor_expr |
| | or_expr '|' xor_expr |
| { |
| $$ = new AstExpression(EC_or, $1, $3); |
| } |
| ; |
| |
| xor_expr : |
| and_expr |
| | xor_expr '^' and_expr |
| { |
| $$ = new AstExpression(EC_xor, $1, $3); |
| } |
| ; |
| |
| and_expr : |
| shift_expr |
| | and_expr '&' shift_expr |
| { |
| $$ = new AstExpression(EC_and, $1, $3); |
| } |
| ; |
| |
| shift_expr : |
| add_expr |
| | shift_expr IDL_LEFTSHIFT add_expr |
| { |
| $$ = new AstExpression(EC_left, $1, $3); |
| } |
| | shift_expr IDL_RIGHTSHIFT add_expr |
| { |
| $$ = new AstExpression(EC_right, $1, $3); |
| } |
| ; |
| |
| add_expr : |
| mult_expr |
| | add_expr '+' mult_expr |
| { |
| $$ = new AstExpression(EC_add, $1, $3); |
| } |
| | add_expr '-' mult_expr |
| { |
| $$ = new AstExpression(EC_minus, $1, $3); |
| } |
| ; |
| |
| mult_expr : |
| unary_expr |
| | mult_expr '*' unary_expr |
| { |
| $$ = new AstExpression(EC_mul, $1, $3); |
| } |
| | mult_expr '/' unary_expr |
| { |
| $$ = new AstExpression(EC_div, $1, $3); |
| } |
| | mult_expr '%' unary_expr |
| { |
| $$ = new AstExpression(EC_mod, $1, $3); |
| } |
| ; |
| |
| unary_expr : |
| primary_expr |
| | '+' primary_expr |
| { |
| $$ = new AstExpression(EC_u_plus, $2, NULL); |
| } |
| | '-' primary_expr |
| { |
| $$ = new AstExpression(EC_u_minus, $2, NULL); |
| } |
| | '~' primary_expr |
| { |
| } |
| ; |
| |
| primary_expr : |
| scoped_name |
| { |
| /* |
| * An expression which is a scoped name is not resolved now, |
| * but only when it is evaluated (such as when it is assigned |
| * as a constant value) |
| */ |
| $$ = new AstExpression($1); |
| } |
| | literal |
| | '(' const_expr ')' |
| { |
| $$ = $2; |
| } |
| ; |
| |
| literal : |
| IDL_INTEGER_LITERAL |
| { |
| $$ = new AstExpression($1); |
| } |
| | IDL_INTEGER_ULITERAL |
| { |
| $$ = new AstExpression($1); |
| } |
| | IDL_FLOATING_PT_LITERAL |
| { |
| $$ = new AstExpression($1); |
| } |
| | IDL_TRUE |
| { |
| $$ = new AstExpression((sal_Int32)1, ET_boolean); |
| } |
| | IDL_FALSE |
| { |
| $$ = new AstExpression((sal_Int32)0, ET_boolean); |
| } |
| ; |
| |
| positive_int_expr : |
| const_expr |
| { |
| $1->evaluate(EK_const); |
| if ( !$1->coerce(ET_ulong) ) |
| { |
| idlc()->error()->coercionError($1, ET_ulong); |
| delete $1; |
| $$ = NULL; |
| } |
| } |
| ; |
| |
| const_type : |
| integer_type |
| | char_type |
| | byte_type |
| | boolean_type |
| | floating_pt_type |
| | scoped_name |
| { |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstDeclaration const * type = 0; |
| |
| /* |
| * If the constant's type is a scoped name, it must resolve |
| * to a scalar constant type |
| */ |
| if ( pScope && (type = pScope->lookupByName(*$1)) ) { |
| if (!idlc()->error()->checkPublished(type)) |
| { |
| type = 0; |
| } |
| else |
| { |
| type = resolveTypedefs(type); |
| if (type->getNodeType() == NT_predefined) |
| { |
| $$ = static_cast< AstBaseType const * >(type)-> |
| getExprType(); |
| } else |
| $$ = ET_any; |
| } |
| } else |
| $$ = ET_any; |
| } |
| ; |
| |
| exception_header : |
| IDL_EXCEPTION |
| { |
| idlc()->setParseState(PS_ExceptSeen); |
| } |
| identifier |
| { |
| idlc()->setParseState(PS_ExceptIDSeen); |
| checkIdentifier($3); |
| } |
| inheritance_spec |
| { |
| idlc()->setParseState(PS_InheritSpecSeen); |
| |
| $$ = new FeInheritanceHeader(NT_exception, $3, $5, 0); |
| delete $5; |
| } |
| ; |
| |
| exception_dcl : |
| exception_header |
| { |
| idlc()->setParseState(PS_ExceptHeaderSeen); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstException* pExcept = NULL; |
| |
| if ( pScope ) |
| { |
| AstException* pBase = static_cast< AstException* >( |
| $1->getInherits()); |
| pExcept = new AstException(*$1->getName(), pBase, pScope); |
| pScope->addDeclaration(pExcept); |
| } |
| /* |
| * Push the scope of the exception on the scopes stack |
| */ |
| idlc()->scopes()->push(pExcept); |
| delete $1; |
| } |
| '{' |
| { |
| idlc()->setParseState(PS_ExceptSqSeen); |
| } |
| members |
| { |
| idlc()->setParseState(PS_ExceptBodySeen); |
| } |
| '}' |
| { |
| idlc()->setParseState(PS_ExceptQsSeen); |
| /* this exception is finished, pop its scope from the stack */ |
| idlc()->scopes()->pop(); |
| } |
| ; |
| |
| property : |
| flag_header |
| simple_type_spec |
| { |
| idlc()->setParseState(PS_PropertyTypeSeen); |
| } |
| at_least_one_declarator |
| { |
| idlc()->setParseState(PS_PropertyCompleted); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstAttribute* pAttr = NULL; |
| FeDeclList* pList = $4; |
| FeDeclarator* pDecl = NULL; |
| AstType const * pType = NULL; |
| |
| if ( pScope->getScopeNodeType() == NT_singleton ) |
| { |
| idlc()->error()->error0(EIDL_ILLEGAL_ADD); |
| } else |
| { |
| if ( ($1 & AF_ATTRIBUTE) == AF_ATTRIBUTE ) |
| idlc()->error()->flagError(EIDL_WRONGATTRIBUTEKEYWORD, AF_ATTRIBUTE); |
| |
| if ( ($1 & AF_PROPERTY) != AF_PROPERTY ) |
| idlc()->error()->flagError(EIDL_MISSINGATTRIBUTEKEYWORD, AF_PROPERTY); |
| |
| /* |
| * Create nodes representing attributes and add them to the |
| * enclosing scope |
| */ |
| if ( pScope && $2 && pList ) |
| { |
| FeDeclList::iterator iter = pList->begin(); |
| FeDeclList::iterator end = pList->end(); |
| |
| while (iter != end) |
| { |
| pDecl = (*iter); |
| if ( !pDecl ) |
| { |
| iter++; |
| continue; |
| } |
| |
| pType = pDecl->compose($2); |
| |
| if ( !pType ) |
| { |
| iter++; |
| continue; |
| } |
| |
| pAttr = new AstAttribute(NT_property, $1, pType, pDecl->getName(), pScope); |
| |
| pScope->addDeclaration(pAttr); |
| iter++; |
| delete pDecl; |
| } |
| } |
| } |
| |
| if ( pList ) |
| delete pList; |
| } |
| | error ';' |
| { |
| yyerror("property"); |
| yyerrok; |
| } |
| ; |
| |
| service_exports : |
| service_exports service_export |
| | /* EMPTY */ |
| ; |
| |
| service_export : |
| service_interface_header |
| at_least_one_scoped_name |
| ';' |
| { |
| idlc()->setParseState(PS_ServiceMemberSeen); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstDeclaration* pDecl = NULL; |
| AstInterfaceMember* pIMember = NULL; |
| |
| if ( pScope->getScopeNodeType() == NT_singleton ) |
| { |
| idlc()->error()->error0(EIDL_ILLEGAL_ADD); |
| } else |
| { |
| /* |
| * Create a node representing a class member. |
| * Store it in the enclosing scope |
| */ |
| if ( pScope && $2 ) |
| { |
| StringList::iterator iter = $2->begin(); |
| StringList::iterator end = $2->end(); |
| |
| while ( iter != end ) |
| { |
| pDecl = pScope->lookupByName(*iter); |
| if ( pDecl && (pDecl->getNodeType() == NT_interface) ) |
| { |
| /* we relax the strict published check and allow to add new |
| * interfaces if they are optional |
| */ |
| bool bOptional = (($1 & AF_OPTIONAL) == AF_OPTIONAL); |
| if ( idlc()->error()->checkPublished(pDecl, bOptional) ) |
| { |
| pIMember = new AstInterfaceMember( |
| $1, (AstInterface*)pDecl, *iter, pScope); |
| pScope->addDeclaration(pIMember); |
| } |
| } else |
| { |
| idlc()->error()-> |
| lookupError(EIDL_INTERFACEMEMBER_LOOKUP, *iter, scopeAsDecl(pScope)); |
| } |
| iter++; |
| } |
| } |
| } |
| delete $2; |
| } |
| | service_service_header |
| at_least_one_scoped_name |
| ';' |
| { |
| idlc()->setParseState(PS_ServiceMemberSeen); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstDeclaration* pDecl = NULL; |
| AstServiceMember* pSMember = NULL; |
| |
| /* |
| * Create a node representing a class member. |
| * Store it in the enclosing scope |
| */ |
| if ( pScope && $2 ) |
| { |
| StringList::iterator iter = $2->begin(); |
| StringList::iterator end = $2->end(); |
| |
| while ( iter != end ) |
| { |
| pDecl = pScope->lookupByName(*iter); |
| if ( pDecl && (pDecl->getNodeType() == NT_service) ) |
| { |
| if ( pScope->getScopeNodeType() == NT_singleton && pScope->nMembers() > 0 ) |
| idlc()->error()->error0(EIDL_ILLEGAL_ADD); |
| else if ( idlc()->error()->checkPublished(pDecl) ) |
| { |
| pSMember = new AstServiceMember( |
| $1, (AstService*)pDecl, *iter, pScope); |
| pScope->addDeclaration(pSMember); |
| } |
| } else |
| { |
| idlc()->error()-> |
| lookupError(EIDL_SERVICEMEMBER_LOOKUP, *iter, scopeAsDecl(pScope)); |
| } |
| iter++; |
| } |
| } |
| delete $2; |
| } |
| | IDL_OBSERVES |
| at_least_one_scoped_name |
| ';' |
| { |
| idlc()->setParseState(PS_ServiceMemberSeen); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstDeclaration* pDecl = NULL; |
| AstObserves* pObserves = NULL; |
| |
| if ( pScope->getScopeNodeType() == NT_singleton ) |
| { |
| idlc()->error()->error0(EIDL_ILLEGAL_ADD); |
| } else |
| { |
| /* |
| * Create a node representing a class member. |
| * Store it in the enclosing scope |
| */ |
| if ( pScope && $2 ) |
| { |
| StringList::iterator iter = $2->begin(); |
| StringList::iterator end = $2->end(); |
| |
| while ( iter != end ) |
| { |
| pDecl = pScope->lookupByName(*iter); |
| if ( pDecl && (pDecl->getNodeType() == NT_interface) ) |
| { |
| pObserves = new AstObserves((AstInterface*)pDecl, *iter, pScope); |
| pScope->addDeclaration(pObserves); |
| } else |
| { |
| idlc()->error()-> |
| lookupError(EIDL_INTERFACEMEMBER_LOOKUP, *iter, scopeAsDecl(pScope)); |
| } |
| iter++; |
| } |
| } |
| } |
| delete $2; |
| } |
| | IDL_NEEDS |
| at_least_one_scoped_name |
| ';' |
| { |
| idlc()->setParseState(PS_ServiceMemberSeen); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstDeclaration* pDecl = NULL; |
| AstNeeds* pNeeds = NULL; |
| |
| if ( pScope->getScopeNodeType() == NT_singleton ) |
| { |
| idlc()->error()->error0(EIDL_ILLEGAL_ADD); |
| } else |
| { |
| /* |
| * Create a node representing a class member. |
| * Store it in the enclosing scope |
| */ |
| if ( pScope && $2 ) |
| { |
| StringList::iterator iter = $2->begin(); |
| StringList::iterator end = $2->end(); |
| |
| while ( iter != end ) |
| { |
| pDecl = pScope->lookupByName(*iter); |
| if ( pDecl && (pDecl->getNodeType() == NT_service) ) |
| { |
| pNeeds = new AstNeeds((AstService*)pDecl, *iter, pScope); |
| pScope->addDeclaration(pNeeds); |
| } else |
| { |
| idlc()->error()-> |
| lookupError(EIDL_SERVICEMEMBER_LOOKUP, *iter, scopeAsDecl(pScope)); |
| } |
| iter++; |
| } |
| } |
| } |
| delete $2; |
| } |
| | property |
| ';' |
| { |
| idlc()->setParseState(PS_PropertyDeclSeen); |
| } |
| ; |
| |
| service_interface_header : |
| IDL_INTERFACE |
| { |
| idlc()->setParseState(PS_ServiceIFHeadSeen); |
| $$ = AF_INVALID; |
| } |
| | flag_header |
| IDL_INTERFACE |
| { |
| idlc()->setParseState(PS_ServiceIFHeadSeen); |
| if ( (AF_OPTIONAL != $1) && ( AF_INVALID != $1) ) |
| idlc()->error()->flagError(EIDL_OPTIONALEXPECTED, $1); |
| $$ = $1; |
| } |
| ; |
| |
| service_service_header : |
| IDL_SERVICE |
| { |
| idlc()->setParseState(PS_ServiceSHeadSeen); |
| $$ = AF_INVALID; |
| } |
| | flag_header |
| IDL_SERVICE |
| { |
| idlc()->setParseState(PS_ServiceSHeadSeen); |
| if ( (AF_OPTIONAL != $1) && ( AF_INVALID != $1) ) |
| idlc()->error()->flagError(EIDL_OPTIONALEXPECTED, $1); |
| $$ = $1; |
| } |
| ; |
| |
| service_dcl : |
| IDL_SERVICE |
| { |
| idlc()->setParseState(PS_ServiceSeen); |
| } |
| identifier |
| { |
| idlc()->setParseState(PS_ServiceIDSeen); |
| checkIdentifier($3); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstService* pService = NULL; |
| |
| /* |
| * Make a new service and add it to the enclosing scope |
| */ |
| if (pScope != NULL) |
| { |
| pService = new AstService(*$3, pScope); |
| pScope->addDeclaration(pService); |
| } |
| delete $3; |
| /* |
| * Push it on the stack |
| */ |
| idlc()->scopes()->push(pService); |
| } |
| service_dfn |
| { |
| /* this service is finished, pop its scope from the stack */ |
| idlc()->scopes()->pop(); |
| } |
| ; |
| |
| service_dfn: |
| service_interface_dfn |
| | service_obsolete_dfn |
| ; |
| |
| service_interface_dfn: |
| ':' scoped_name |
| { |
| AstScope * scope = idlc()->scopes()->nextToTop(); |
| // skip the scope pushed by service_dcl |
| AstDeclaration * decl = scope->lookupByName(*$2); |
| if (decl != 0 && resolveTypedefs(decl)->getNodeType() == NT_interface) { |
| if (idlc()->error()->checkPublished(decl)) { |
| idlc()->scopes()->top()->addDeclaration(decl); |
| } |
| } else { |
| idlc()->error()->lookupError( |
| EIDL_INTERFACEMEMBER_LOOKUP, *$2, scopeAsDecl(scope)); |
| } |
| delete $2; |
| } |
| opt_service_body |
| { |
| AstService * s = static_cast< AstService * >(idlc()->scopes()->top()); |
| if (s != 0) { |
| s->setDefaultConstructor(!$4); |
| } |
| } |
| ; |
| |
| opt_service_body: |
| service_body { $$ = true; } |
| | /* empty */ { $$ = false; } |
| ; |
| |
| service_body: |
| '{' |
| constructors |
| '}' |
| ; |
| |
| constructors: |
| constructors constructor |
| | /* empty */ |
| ; |
| |
| constructor: |
| identifier |
| { |
| checkIdentifier($1); |
| AstScope * scope = idlc()->scopes()->top(); |
| AstOperation * ctor = new AstOperation(OP_NONE, 0, *$1, scope); |
| delete $1; |
| scope->addDeclaration(ctor); |
| idlc()->scopes()->push(ctor); |
| } |
| '(' |
| parameters |
| ')' |
| opt_raises |
| { |
| static_cast< AstOperation * >(idlc()->scopes()->top())->setExceptions( |
| $6); |
| delete $6; |
| idlc()->scopes()->pop(); |
| if (static_cast< AstService * >(idlc()->scopes()->top())-> |
| checkLastConstructor()) |
| { |
| idlc()->error()->error0(EIDL_SIMILAR_CONSTRUCTORS); |
| } |
| } |
| ';' |
| ; |
| |
| singleton_dcl : |
| IDL_SINGLETON |
| { |
| idlc()->setParseState(PS_SingletonSeen); |
| } |
| identifier |
| { |
| idlc()->setParseState(PS_SingletonIDSeen); |
| checkIdentifier($3); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstService* pService = NULL; |
| |
| /* |
| * Make a new service and add it to the enclosing scope |
| */ |
| if (pScope != NULL) |
| { |
| pService = new AstService(NT_singleton, *$3, pScope); |
| pScope->addDeclaration(pService); |
| } |
| delete $3; |
| /* |
| * Push it on the stack |
| */ |
| idlc()->scopes()->push(pService); |
| } |
| singleton_dfn |
| { |
| /* this singelton is finished, pop its scope from the stack */ |
| idlc()->scopes()->pop(); |
| } |
| ; |
| |
| singleton_dfn: |
| singleton_interface_dfn |
| | service_obsolete_dfn |
| ; |
| |
| singleton_interface_dfn: |
| ':' scoped_name |
| { |
| AstScope * scope = idlc()->scopes()->nextToTop(); |
| // skip the scope (needlessly) pushed by singleton_dcl |
| AstDeclaration * decl = scope->lookupByName(*$2); |
| if (decl != 0 && resolveTypedefs(decl)->getNodeType() == NT_interface) { |
| if (idlc()->error()->checkPublished(decl)) { |
| idlc()->scopes()->top()->addDeclaration(decl); |
| } |
| } else { |
| idlc()->error()->lookupError( |
| EIDL_INTERFACEMEMBER_LOOKUP, *$2, scopeAsDecl(scope)); |
| } |
| delete $2; |
| } |
| ; |
| |
| service_obsolete_dfn: |
| '{' |
| { |
| idlc()->setParseState( |
| idlc()->scopes()->top()->getScopeNodeType() == NT_service |
| ? PS_ServiceSqSeen : PS_SingletonSqSeen); |
| } |
| service_exports |
| { |
| idlc()->setParseState( |
| idlc()->scopes()->top()->getScopeNodeType() == NT_service |
| ? PS_ServiceBodySeen : PS_SingletonBodySeen); |
| } |
| '}' |
| { |
| idlc()->setParseState( |
| idlc()->scopes()->top()->getScopeNodeType() == NT_service |
| ? PS_ServiceQsSeen : PS_SingletonQsSeen); |
| } |
| ; |
| |
| type_dcl : |
| IDL_TYPEDEF |
| { |
| idlc()->setParseState(PS_TypedefSeen); |
| } |
| type_declarator {} |
| | struct_type {} |
| | union_type {} |
| | enum_type {} |
| ; |
| |
| type_declarator : |
| type_spec |
| { |
| idlc()->setParseState(PS_TypeSpecSeen); |
| if ($1 != 0 && $1->getNodeType() == NT_instantiated_struct) { |
| idlc()->error()->error0(EIDL_INSTANTIATED_STRUCT_TYPE_TYPEDEF); |
| } |
| } |
| at_least_one_declarator |
| { |
| idlc()->setParseState(PS_DeclaratorsSeen); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstTypeDef* pTypeDef = NULL; |
| FeDeclList* pList = $3; |
| FeDeclarator* pDecl = NULL; |
| AstType const * pType = NULL; |
| |
| /* |
| * Create nodes representing typedefs and add them to the |
| * enclosing scope |
| */ |
| if ( pScope && $1 && pList ) |
| { |
| FeDeclList::iterator iter = pList->begin(); |
| FeDeclList::iterator end = pList->end(); |
| |
| while (iter != end) |
| { |
| pDecl = (*iter); |
| if ( !pDecl ) |
| { |
| iter++; |
| continue; |
| } |
| |
| pType = pDecl->compose($1); |
| |
| if ( !pType ) |
| { |
| iter++; |
| continue; |
| } |
| |
| pTypeDef = new AstTypeDef(pType, pDecl->getName(), pScope); |
| |
| pScope->addDeclaration(pTypeDef); |
| iter++; |
| delete pDecl; |
| } |
| delete pList; |
| } |
| } |
| ; |
| |
| at_least_one_declarator : |
| declarator declarators |
| { |
| if ( $2 ) |
| { |
| $2->push_back($1); |
| $$ = $2; |
| } else |
| { |
| FeDeclList* pList = new FeDeclList(); |
| pList->push_back($1); |
| $$ = pList; |
| } |
| } |
| ; |
| |
| declarators : |
| declarators |
| ',' |
| { |
| idlc()->setParseState(PS_DeclsCommaSeen); |
| } |
| declarator |
| { |
| idlc()->setParseState(PS_DeclsDeclSeen); |
| if ( $1 ) |
| { |
| $1->push_back($4); |
| $$ = $1; |
| } else |
| { |
| FeDeclList* pList = new FeDeclList(); |
| pList->push_back($4); |
| $$ = pList; |
| } |
| } |
| | /* EMPTY */ |
| { |
| $$ = NULL; |
| } |
| ; |
| |
| declarator : |
| simple_declarator |
| | complex_declarator |
| ; |
| |
| simple_declarator : |
| identifier |
| { |
| // For historic reasons, the struct com.sun.star.uno.Uik contains |
| // members with illegal names (of the form "m_DataN"); avoid useless |
| // warnings about them: |
| AstScope * scope = idlc()->scopes()->top(); |
| if (scope == 0 || scope->getScopeNodeType() != NT_struct |
| || (scopeAsDecl(scope)->getScopedName() |
| != "com::sun::star::uno::Uik")) |
| { |
| checkIdentifier($1); |
| } |
| |
| $$ = new FeDeclarator(*$1, FeDeclarator::FD_simple, NULL); |
| delete $1; |
| } |
| ; |
| |
| complex_declarator : |
| array_declarator |
| { |
| $$ = new FeDeclarator($1->getLocalName(), FeDeclarator::FD_complex, $1); |
| } |
| ; |
| |
| array_declarator : |
| identifier |
| { |
| idlc()->setParseState(PS_ArrayIDSeen); |
| checkIdentifier($1); |
| } |
| at_least_one_array_dim |
| { |
| idlc()->setParseState(PS_ArrayCompleted); |
| $$ = new AstArray(*$1, NULL, *$3, idlc()->scopes()->bottom()); |
| delete $1; |
| } |
| ; |
| |
| at_least_one_array_dim : |
| array_dim array_dims |
| { |
| if( $2 ) |
| { |
| $2->push_front($1); |
| $$ = $2; |
| } else |
| { |
| ExprList* pList = new ExprList(); |
| pList->push_back($1); |
| $$ = pList; |
| } |
| } |
| ; |
| |
| array_dims : |
| array_dims array_dim |
| { |
| if( $1 ) |
| { |
| $1->push_back($2); |
| $$ = $1; |
| } else |
| { |
| ExprList* pList = new ExprList(); |
| pList->push_back($2); |
| $$ = pList; |
| } |
| } |
| | /* EMPTY */ |
| { |
| $$ = NULL; |
| } |
| ; |
| |
| array_dim : |
| '[' |
| { |
| idlc()->setParseState(PS_DimSqSeen); |
| } |
| positive_int_expr |
| { |
| idlc()->setParseState(PS_DimExprSeen); |
| } |
| ']' |
| { |
| idlc()->setParseState(PS_DimQsSeen); |
| /* |
| * Array dimensions are expressions which must be coerced to |
| * positive integers |
| */ |
| if ( !$3 || !$3->coerce(ET_uhyper) ) |
| { |
| idlc()->error()->coercionError($3, ET_uhyper); |
| $$ = NULL; |
| } else |
| $$ = $3; |
| } |
| ; |
| |
| at_least_one_scoped_name : |
| scoped_name scoped_names |
| { |
| if ($2) |
| { |
| $2->push_front(*$1); |
| $$ = $2; |
| } else |
| { |
| StringList* pNames = new StringList(); |
| pNames->push_back(*$1); |
| $$ = pNames; |
| } |
| delete($1); |
| } |
| ; |
| |
| scoped_names : |
| scoped_names |
| ',' |
| { |
| idlc()->setParseState(PS_SNListCommaSeen); |
| } |
| scoped_name |
| { |
| idlc()->setParseState(PS_ScopedNameSeen); |
| if ($1) |
| { |
| $1->push_back(*$4); |
| $$ = $1; |
| } else |
| { |
| StringList* pNames = new StringList(); |
| pNames->push_back(*$4); |
| $$ = pNames; |
| } |
| delete($4); |
| } |
| | /* EMPTY */ |
| { |
| $$ = NULL; |
| } |
| ; |
| |
| scoped_name : |
| identifier |
| { |
| idlc()->setParseState(PS_SN_IDSeen); |
| checkIdentifier($1); |
| $$ = $1; |
| } |
| | IDL_SCOPESEPARATOR |
| { |
| idlc()->setParseState(PS_ScopeDelimSeen); |
| } |
| identifier |
| { |
| checkIdentifier($3); |
| OString* pName = new OString("::"); |
| *pName += *$3; |
| delete $3; |
| $$ = pName; |
| } |
| | scoped_name |
| IDL_SCOPESEPARATOR |
| { |
| } |
| identifier |
| { |
| checkIdentifier($4); |
| *$1 += ::rtl::OString("::"); |
| *$1 += *$4; |
| delete $4; |
| $$ = $1; |
| } |
| ; |
| |
| type_spec : |
| simple_type_spec |
| | constructed_type_spec |
| ; |
| |
| simple_type_spec : |
| fundamental_type |
| | scoped_name opt_type_args |
| { |
| $$ = createNamedType($1, $2); |
| } |
| ; |
| |
| fundamental_type: |
| base_type_spec |
| { |
| $$ = idlc()->scopes()->bottom()->lookupPrimitiveType($1); |
| } |
| | template_type_spec |
| ; |
| |
| opt_type_args: |
| '<' type_args '>' { $$ = $2; } |
| | /* empty */ { $$ = 0; } |
| ; |
| |
| type_args: |
| type_arg |
| { |
| $$ = new DeclList; |
| $$->push_back(const_cast< AstDeclaration * >($1)); //TODO: const_cast |
| } |
| | type_args ',' type_arg |
| { |
| $1->push_back(const_cast< AstDeclaration * >($3)); //TODO: const_cast |
| $$ = $1; |
| } |
| ; |
| |
| type_arg: |
| simple_type_spec |
| { |
| if ($1 != 0 && static_cast< AstType const * >($1)->isUnsigned()) { |
| idlc()->error()->error0(EIDL_UNSIGNED_TYPE_ARGUMENT); |
| } |
| $$ = $1; |
| } |
| ; |
| |
| base_type_spec : |
| integer_type |
| | floating_pt_type |
| | char_type |
| | boolean_type |
| | byte_type |
| | any_type |
| | type_type |
| | string_type |
| ; |
| |
| integer_type : |
| signed_int |
| | unsigned_int |
| ; |
| |
| signed_int : |
| IDL_LONG |
| { |
| $$ = ET_long; |
| } |
| | IDL_HYPER |
| { |
| $$ = ET_hyper; |
| } |
| | IDL_SHORT |
| { |
| $$ = ET_short; |
| } |
| ; |
| |
| unsigned_int : |
| IDL_UNSIGNED IDL_LONG |
| { |
| $$ = ET_ulong; |
| } |
| | IDL_UNSIGNED IDL_HYPER |
| { |
| $$ = ET_uhyper; |
| } |
| | IDL_UNSIGNED IDL_SHORT |
| { |
| $$ = ET_ushort; |
| } |
| ; |
| |
| floating_pt_type : |
| IDL_DOUBLE |
| { |
| $$ = ET_double; |
| } |
| | IDL_FLOAT |
| { |
| $$ = ET_float; |
| } |
| ; |
| |
| char_type : |
| IDL_CHAR |
| { |
| $$ = ET_char; |
| } |
| ; |
| |
| byte_type : |
| IDL_BYTE |
| { |
| $$ = ET_byte; |
| } |
| ; |
| |
| boolean_type : |
| IDL_BOOLEAN |
| { |
| $$ = ET_boolean; |
| } |
| ; |
| |
| any_type : |
| IDL_ANY |
| { |
| $$ = ET_any; |
| } |
| ; |
| |
| type_type : |
| IDL_TYPE |
| { |
| $$ = ET_type; |
| } |
| ; |
| |
| string_type : |
| IDL_STRING |
| { |
| $$ = ET_string; |
| } |
| ; |
| |
| template_type_spec : |
| sequence_type_spec |
| | array_type |
| ; |
| |
| constructed_type_spec : |
| struct_type |
| | union_type |
| | enum_type |
| ; |
| |
| array_type : |
| simple_type_spec |
| { |
| idlc()->setParseState(PS_ArrayTypeSeen); |
| } |
| at_least_one_array_dim |
| { |
| idlc()->setParseState(PS_ArrayCompleted); |
| |
| AstScope* pScope = idlc()->scopes()->bottom(); |
| AstDeclaration* pDecl = NULL; |
| AstDeclaration* pArray = NULL; |
| |
| if ( $1 ) |
| { |
| pArray = new AstArray((AstType*)$1, *$3, idlc()->scopes()->bottom()); |
| if ( pScope ) |
| { |
| pDecl = pScope->addDeclaration(pArray); |
| if ( pArray != pDecl ) |
| { |
| // if array type already defined then use it |
| delete pArray; |
| pArray = pDecl; |
| } |
| } |
| } |
| $$ = pArray; |
| } |
| ; |
| |
| sequence_type_spec : |
| IDL_SEQUENCE |
| { |
| idlc()->setParseState(PS_SequenceSeen); |
| /* |
| * Push a sequence marker on scopes stack |
| */ |
| idlc()->scopes()->push(NULL); |
| } |
| '<' |
| { |
| idlc()->setParseState(PS_SequenceSqSeen); |
| } |
| simple_type_spec |
| { |
| idlc()->setParseState(PS_SequenceTypeSeen); |
| } |
| '>' |
| { |
| idlc()->setParseState(PS_SequenceQsSeen); |
| /* |
| * Remove sequence marker from scopes stack |
| */ |
| if (idlc()->scopes()->top() == NULL) |
| idlc()->scopes()->pop(); |
| /* |
| * Create a node representing a sequence |
| */ |
| AstScope* pScope = idlc()->scopes()->bottom(); |
| AstDeclaration* pDecl = NULL; |
| AstDeclaration* pSeq = NULL; |
| |
| if ( $5 ) |
| { |
| AstType *pType = (AstType*)$5; |
| if ( pType ) |
| { |
| pSeq = new AstSequence(pType, pScope); |
| /* |
| * Add this AstSequence to the types defined in the global scope |
| */ |
| pDecl = pScope->addDeclaration(pSeq); |
| if ( pSeq != pDecl ) |
| { |
| // if sequence type already defined then use it |
| delete pSeq; |
| pSeq = pDecl; |
| } |
| } |
| } |
| $$ = pSeq; |
| } |
| | error '>' |
| { |
| yyerror("sequence declaration"); |
| yyerrok; |
| $$ = 0; |
| } |
| ; |
| |
| struct_type : |
| structure_header |
| { |
| idlc()->setParseState(PS_StructHeaderSeen); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstStruct* pStruct = NULL; |
| |
| if ( pScope ) |
| { |
| AstStruct* pBase= static_cast< AstStruct* >($1->getInherits()); |
| pStruct = new AstStruct( |
| *$1->getName(), $1->getTypeParameters(), pBase, pScope); |
| pScope->addDeclaration(pStruct); |
| } |
| /* |
| * Push the scope of the struct on the scopes stack |
| */ |
| idlc()->scopes()->push(pStruct); |
| delete $1; |
| } |
| '{' |
| { |
| idlc()->setParseState(PS_StructSqSeen); |
| } |
| at_least_one_member |
| { |
| idlc()->setParseState(PS_StructBodySeen); |
| } |
| '}' |
| { |
| idlc()->setParseState(PS_StructQsSeen); |
| /* this exception is finished, pop its scope from the stack */ |
| idlc()->scopes()->pop(); |
| } |
| ; |
| |
| structure_header : |
| IDL_STRUCT |
| { |
| idlc()->setParseState(PS_StructSeen); |
| } |
| identifier |
| { |
| idlc()->setParseState(PS_StructIDSeen); |
| checkIdentifier($3); |
| } |
| opt_type_params |
| inheritance_spec |
| { |
| idlc()->setParseState(PS_InheritSpecSeen); |
| |
| // Polymorphic struct type templates with base types would cause various |
| // problems in language bindings, so forbid them here. For example, |
| // GCC prior to version 3.4 fails with code like |
| // |
| // struct Base { ... }; |
| // template< typename typeparam_T > struct Derived: public Base { |
| // int member1 CPPU_GCC3_ALIGN(Base); |
| // ... }; |
| // |
| // (Note that plain struct types with instantiated polymorphic struct |
| // type bases, which might also cause problems in language bindings, are |
| // already rejected on a syntactic level.) |
| if ($5 != 0 && $6 != 0) { |
| idlc()->error()->error0(EIDL_STRUCT_TYPE_TEMPLATE_WITH_BASE); |
| } |
| |
| $$ = new FeInheritanceHeader(NT_struct, $3, $6, $5); |
| delete $5; |
| delete $6; |
| } |
| ; |
| |
| opt_type_params: |
| '<' type_params '>' { $$ = $2; } |
| | /* empty */ { $$ = 0; } |
| ; |
| |
| type_params: |
| identifier |
| { |
| $$ = new std::vector< rtl::OString >; |
| $$->push_back(*$1); |
| delete $1; |
| } |
| | type_params ',' identifier |
| { |
| if (std::find($1->begin(), $1->end(), *$3) != $1->end()) { |
| idlc()->error()->error0(EIDL_IDENTICAL_TYPE_PARAMETERS); |
| } |
| $1->push_back(*$3); |
| delete $3; |
| $$ = $1; |
| } |
| ; |
| |
| at_least_one_member : member members ; |
| |
| members : |
| members member |
| | /* EMPTY */ |
| ; |
| |
| member : |
| type_or_parameter |
| { |
| idlc()->setParseState(PS_MemberTypeSeen); |
| } |
| at_least_one_declarator |
| { |
| idlc()->setParseState(PS_MemberDeclsSeen); |
| } |
| ';' |
| { |
| idlc()->setParseState(PS_MemberDeclsCompleted); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstMember* pMember = NULL; |
| FeDeclList* pList = $3; |
| FeDeclarator* pDecl = NULL; |
| AstType const * pType = NULL; |
| |
| // !!! check recursive type |
| |
| if ( pScope && pList && $1 ) |
| { |
| FeDeclList::iterator iter = pList->begin(); |
| FeDeclList::iterator end = pList->end(); |
| while (iter != end) |
| { |
| pDecl = (*iter); |
| if ( !pDecl ) |
| { |
| iter++; |
| continue; |
| } |
| |
| pType = pDecl->compose($1); |
| |
| if ( !pType ) |
| { |
| iter++; |
| continue; |
| } |
| |
| pMember = new AstMember(pType, pDecl->getName(), pScope); |
| |
| if ( !pDecl->checkType($1) ) |
| { |
| // WARNING |
| } |
| |
| pScope->addDeclaration(pMember); |
| iter++; |
| delete pDecl; |
| } |
| delete pList; |
| } |
| } |
| | error ';' |
| { |
| yyerror("member definition"); |
| yyerrok; |
| } |
| ; |
| |
| type_or_parameter: |
| fundamental_type |
| | scoped_name opt_type_args |
| { |
| AstDeclaration const * decl = 0; |
| AstStruct * scope = static_cast< AstStruct * >(idlc()->scopes()->top()); |
| if (scope != 0 && $2 == 0) { |
| decl = scope->findTypeParameter(*$1); |
| } |
| if (decl != 0) { |
| delete $1; |
| delete $2; |
| } else { |
| decl = createNamedType($1, $2); |
| if (scope != 0 && includes(decl, scopeAsDecl(scope))) { |
| idlc()->error()->error1( |
| EIDL_RECURSIVE_TYPE, scopeAsDecl(scope)); |
| decl = 0; |
| } |
| } |
| $$ = decl; |
| } |
| ; |
| |
| enum_type : |
| IDL_ENUM |
| { |
| idlc()->setParseState(PS_EnumSeen); |
| } |
| identifier |
| { |
| idlc()->setParseState(PS_EnumIDSeen); |
| checkIdentifier($3); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstEnum* pEnum = NULL; |
| |
| /* |
| * Create a node representing an enum and add it to its |
| * enclosing scope |
| */ |
| if (pScope != NULL) |
| { |
| pEnum = new AstEnum(*$3, pScope); |
| /* |
| * Add it to its defining scope |
| */ |
| pScope->addDeclaration(pEnum); |
| } |
| delete $3; |
| /* |
| * Push the enum scope on the scopes stack |
| */ |
| idlc()->scopes()->push(pEnum); |
| |
| } |
| '{' |
| { |
| idlc()->setParseState(PS_EnumSqSeen); |
| } |
| at_least_one_enumerator |
| { |
| idlc()->setParseState(PS_EnumBodySeen); |
| } |
| '}' |
| { |
| idlc()->setParseState(PS_EnumQsSeen); |
| /* |
| * Done with this enum. Pop its scope from the scopes stack |
| */ |
| if (idlc()->scopes()->top() == NULL) |
| $$ = NULL; |
| else |
| { |
| $$ = (AstEnum*)idlc()->scopes()->topNonNull(); |
| idlc()->scopes()->pop(); |
| } |
| } |
| ; |
| |
| at_least_one_enumerator : enumerator enumerators ; |
| |
| enumerators : |
| enumerators |
| ',' |
| { |
| idlc()->setParseState(PS_EnumCommaSeen); |
| } |
| enumerator |
| | /* EMPTY */ |
| | error ',' |
| { |
| yyerror("enumerator definition"); |
| yyerrok; |
| } |
| ; |
| |
| enumerator : |
| identifier |
| { |
| checkIdentifier($1); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstEnum* pEnum = NULL; |
| AstConstant* pEnumVal = NULL; |
| |
| if ( pScope && pScope->getScopeNodeType() == NT_enum) |
| { |
| pEnum = (AstEnum*)pScope; |
| if (pEnum && $1) |
| { |
| AstExpression* pExpr = new AstExpression(pEnum->getEnumValueCount()); |
| pEnumVal = new AstConstant(ET_long , NT_enum_val, |
| pExpr, *$1, pScope); |
| } |
| if ( pEnum->checkValue(pEnumVal->getConstValue()) ) |
| idlc()->error()->error1(EIDL_EVAL_ERROR, pEnum); |
| |
| pScope->addDeclaration(pEnumVal); |
| } |
| delete $1; |
| } |
| | identifier |
| '=' |
| const_expr |
| { |
| checkIdentifier($1); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstEnum* pEnum = NULL; |
| AstConstant* pEnumVal = NULL; |
| |
| if ( $3 && pScope && pScope->getScopeNodeType() == NT_enum) |
| { |
| $3->evaluate(EK_const); |
| if ( $3->coerce(ET_long) ) |
| { |
| pEnum = (AstEnum*)pScope; |
| if (pEnum) |
| { |
| pEnumVal = new AstConstant(ET_long , NT_enum_val, |
| $3, *$1, pScope); |
| } |
| if ( pEnum->checkValue(pEnumVal->getConstValue()) ) |
| idlc()->error()->error1(EIDL_EVAL_ERROR, pEnum); |
| |
| pScope->addDeclaration(pEnumVal); |
| } else |
| { |
| idlc()->error()->coercionError($3, ET_long); |
| delete $3; |
| } |
| } |
| delete $1; |
| } |
| ; |
| |
| union_type : |
| IDL_UNION |
| { |
| idlc()->setParseState(PS_UnionSeen); |
| } |
| identifier |
| { |
| idlc()->setParseState(PS_UnionIDSeen); |
| checkIdentifier($3); |
| } |
| IDL_SWITCH |
| { |
| idlc()->setParseState(PS_SwitchSeen); |
| } |
| '(' |
| { |
| idlc()->setParseState(PS_SwitchOpenParSeen); |
| } |
| switch_type_spec |
| { |
| idlc()->setParseState(PS_SwitchTypeSeen); |
| } |
| ')' |
| { |
| idlc()->setParseState(PS_SwitchCloseParSeen); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstUnion* pUnion = NULL; |
| |
| /* |
| * Create a node representing a union. Add it to its enclosing |
| * scope |
| */ |
| if ( $9 && pScope ) |
| { |
| AstType* pType = (AstType*)$9; |
| if ( !pType) |
| { |
| idlc()->error()->noTypeError($9); |
| } else |
| { |
| pUnion = new AstUnion(*$3, pType, pScope); |
| pScope->addDeclaration(pUnion); |
| } |
| } |
| delete $3; |
| /* |
| * Push the scope of the union on the scopes stack |
| */ |
| idlc()->scopes()->push(pUnion); |
| } |
| '{' |
| { |
| idlc()->setParseState(PS_UnionSqSeen); |
| } |
| at_least_one_case_branch |
| { |
| idlc()->setParseState(PS_UnionBodySeen); |
| } |
| '}' |
| { |
| idlc()->setParseState(PS_UnionQsSeen); |
| /* this union is finished, pop its scope from the stack */ |
| idlc()->scopes()->pop(); |
| } |
| ; |
| |
| switch_type_spec : |
| integer_type |
| { |
| $$ = idlc()->scopes()->bottom()->lookupPrimitiveType($1); |
| } |
| | char_type |
| { |
| $$ = idlc()->scopes()->bottom()->lookupPrimitiveType($1); |
| } |
| | boolean_type |
| { |
| $$ = idlc()->scopes()->bottom()->lookupPrimitiveType($1); |
| } |
| | enum_type |
| | scoped_name |
| { |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstBaseType* pBaseType = NULL; |
| AstDeclaration const * pDecl = NULL; |
| AstTypeDef* pTypeDef = NULL; |
| sal_Bool bFound = sal_False; |
| /* |
| * If the constant's type is a scoped name, it must resolve |
| * to a scalar constant type |
| */ |
| if ( pScope && (pDecl = pScope->lookupByName(*$1)) ) |
| { |
| /* |
| * Look through typedefs |
| */ |
| while ( !bFound ) |
| { |
| switch (pDecl->getNodeType()) |
| { |
| case NT_enum: |
| $$ = pDecl; |
| bFound = sal_True; |
| break; |
| case NT_predefined: |
| pBaseType = (AstBaseType*)pDecl; |
| if ( pBaseType ) |
| { |
| switch (pBaseType->getExprType()) |
| { |
| case ET_short: |
| case ET_ushort: |
| case ET_long: |
| case ET_ulong: |
| case ET_hyper: |
| case ET_uhyper: |
| case ET_char: |
| case ET_byte: |
| case ET_boolean: |
| $$ = pBaseType; |
| bFound = sal_True; |
| break; |
| default: |
| $$ = NULL; |
| bFound = sal_True; |
| break; |
| } |
| } |
| break; |
| case NT_typedef: |
| pTypeDef = (AstTypeDef*)pDecl; |
| if ( pTypeDef ) |
| pDecl = pTypeDef->getBaseType(); |
| break; |
| default: |
| $$ = NULL; |
| bFound = sal_True; |
| break; |
| } |
| } |
| } else |
| $$ = NULL; |
| |
| if ($$ == NULL) |
| idlc()->error()->lookupError(*$1); |
| } |
| ; |
| |
| at_least_one_case_branch : case_branch case_branches ; |
| |
| case_branches : |
| case_branches case_branch |
| | /* EMPTY */ |
| ; |
| |
| case_branch : |
| at_least_one_case_label |
| { |
| idlc()->setParseState(PS_UnionLabelSeen); |
| } |
| element_spec |
| { |
| idlc()->setParseState(PS_UnionElemSeen); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| AstUnionLabel* pLabel = NULL; |
| AstUnionBranch* pBranch = NULL; |
| AstMember* pMember = $3; |
| |
| /* |
| * Create several nodes representing branches of a union. |
| * Add them to the enclosing scope (the union scope) |
| */ |
| if ( pScope && $1 && $3 ) |
| { |
| LabelList::iterator iter = $1->begin(); |
| LabelList::iterator end = $1->end(); |
| for (;iter != end; iter++) |
| { |
| pLabel = *iter; |
| if ( !pLabel ) |
| { |
| iter++; |
| continue; |
| } |
| pBranch = new AstUnionBranch(pLabel, pMember->getType(), |
| pMember->getLocalName(), pScope); |
| pScope->addDeclaration(pBranch); |
| } |
| } |
| if ( $1 ) delete($1); |
| } |
| ; |
| |
| at_least_one_case_label : |
| case_label case_labels |
| { |
| if ( $2 ) |
| { |
| $2->push_front($1); |
| $$ = $2; |
| } else |
| { |
| LabelList* pLabels = new LabelList(); |
| pLabels->push_back($1); |
| $$ = pLabels; |
| } |
| } |
| ; |
| |
| case_labels : |
| case_labels case_label |
| { |
| if ( $1 ) |
| { |
| $1->push_back($2); |
| $$ = $1; |
| } else |
| { |
| LabelList* pLabels = new LabelList(); |
| pLabels->push_back($2); |
| $$ = pLabels; |
| } |
| } |
| | /* EMPTY */ |
| { |
| $$ = NULL; |
| } |
| ; |
| |
| case_label : |
| IDL_DEFAULT |
| { |
| idlc()->setParseState(PS_DefaultSeen); |
| } |
| ':' |
| { |
| idlc()->setParseState(PS_LabelColonSeen); |
| $$ = new AstUnionLabel(UL_default, NULL); |
| } |
| | IDL_CASE |
| { |
| idlc()->setParseState(PS_CaseSeen); |
| } |
| const_expr |
| { |
| idlc()->setParseState(PS_LabelExprSeen); |
| } |
| ':' |
| { |
| idlc()->setParseState(PS_LabelColonSeen); |
| $$ = new AstUnionLabel(UL_label, $3); |
| } |
| ; |
| |
| element_spec : |
| type_spec |
| { |
| idlc()->setParseState(PS_UnionElemTypeSeen); |
| } |
| declarator |
| { |
| idlc()->setParseState(PS_UnionElemDeclSeen); |
| } |
| ';' |
| { |
| idlc()->setParseState(PS_UnionElemCompleted); |
| |
| AstScope* pScope = idlc()->scopes()->topNonNull(); |
| /* |
| * Check for illegal recursive use of type |
| */ |
| // if ( $1 && AST_illegal_recursive_type($1)) |
| // idlc()->error()->error1(EIDL_RECURSIVE_TYPE, $1); |
| /* |
| * Create a field in a union branch |
| */ |
| if ( $1 && $3 ) |
| { |
| AstType const * pType = $3->compose($1); |
| if ( !pType ) |
| $$ = NULL; |
| else |
| $$ = new AstMember(pType, $3->getName(), pScope); |
| } else |
| $$ = NULL; |
| |
| if ( $3 ) delete $3; |
| } |
| | error |
| ';' |
| { |
| $$ = NULL; |
| } |
| ; |
| |
| identifier: |
| IDL_IDENTIFIER |
| | IDL_GET { $$ = new OString("get"); } |
| | IDL_SET { $$ = new OString("set"); } |
| | IDL_PUBLISHED { $$ = new OString("published"); } |
| ; |
| |
| %% |
| |
| /* |
| * Report an error situation discovered in a production |
| */ |
| void yyerror(char const *errmsg) |
| { |
| idlc()->error()->syntaxError(idlc()->getParseState(), idlc()->getLineNumber(), errmsg); |
| idlc()->setParseState(PS_NoState); |
| } |
