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