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