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