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