1 : //==============================================================================
2 : // File <$/src/cpp/dev/idlc/idl_bison.yy>
3 : // This file is part of YaOrb : Yet Another Object Request Broker,
4 : // Copyright (c) 2000-2003, 2006, Marc Alff.
5 : //
6 : // This program is free software; you can redistribute it and/or
7 : // modify it under the terms of the GNU General Public License
8 : // as published by the Free Software Foundation; either version 2
9 : // of the License, or (at your option) any later version.
10 : //
11 : // This program is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 : //
16 : // You should have received a copy of the GNU General Public License
17 : // along with this program; if not, write to the Free Software
18 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 : //
20 : //==============================================================================
21 :
22 : /* REFERENCE : OMG Document 99-07-07 */
23 :
24 : %start specification
25 :
26 : %{
27 : // generated from File <$/src/cpp/dev/idlc/idl_bison.yy>
28 : // This file is part of YaOrb : Yet Another Object Request Broker,
29 : // Copyright (c) 2000-2003, Marc Alff.
30 : //
31 : // This program is free software; you can redistribute it and/or
32 : // modify it under the terms of the GNU General Public License
33 : // as published by the Free Software Foundation; either version 2
34 : // of the License, or (at your option) any later version.
35 : //
36 : // This program is distributed in the hope that it will be useful,
37 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
38 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
39 : // GNU General Public License for more details.
40 : //
41 : // You should have received a copy of the GNU General Public License
42 : // along with this program; if not, write to the Free Software
43 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
44 : //
45 :
46 : #include <stdio.h>
47 : #include <iostream>
48 :
49 : #include "src/cpp/prod/tool/DEVELOPMENT.h"
50 :
51 : #include "src/cpp/prod/tool/Assert.h"
52 : #include "src/cpp/prod/tool/String.h"
53 : #include "src/cpp/prod/tool/WString.h"
54 :
55 : #include "src/cpp/dev/idlc/yyutils.h"
56 : #include "src/cpp/dev/idlc/all_symbols.h"
57 : #include "src/cpp/dev/idlc/struct.h"
58 : #include "src/cpp/dev/idlc/exception.h"
59 : #include "src/cpp/dev/idlc/struct_member.h"
60 : #include "src/cpp/dev/idlc/enum.h"
61 : #include "src/cpp/dev/idlc/enum_item.h"
62 : #include "src/cpp/dev/idlc/simple_declarator.h"
63 : #include "src/cpp/dev/idlc/array_declarator.h"
64 : #include "src/cpp/dev/idlc/parameter.h"
65 : #include "src/cpp/dev/idlc/attribute.h"
66 : #include "src/cpp/dev/idlc/interface.h"
67 : #include "src/cpp/dev/idlc/native.h"
68 : #include "src/cpp/dev/idlc/typedef.h"
69 : #include "src/cpp/dev/idlc/idl_type.h"
70 : #include "src/cpp/dev/idlc/value.h"
71 : #include "src/cpp/dev/idlc/boolean_value.h"
72 : #include "src/cpp/dev/idlc/int_value.h"
73 : #include "src/cpp/dev/idlc/char_value.h"
74 : #include "src/cpp/dev/idlc/string_value.h"
75 : #include "src/cpp/dev/idlc/wstring_value.h"
76 : #include "src/cpp/dev/idlc/const_exp.h"
77 : #include "src/cpp/dev/idlc/sym_tab.h"
78 : #include "src/cpp/dev/idlc/scope.h"
79 :
80 :
81 : /*
82 : ** ReverseTypeDeclaration is used to do the following :
83 : **
84 : ** convert two syntaxic trees into a type tree.
85 : **
86 : ** Example :
87 : ** =========
88 : **
89 : ** the IDL source being parsed is like : long tab3D[10][20][30]
90 : **
91 : ** INPUT :
92 : ** =======
93 : ** (type) contains :
94 : ** -IDLType (long)
95 : **
96 : ** (decl) contains :
97 : ** - array_declarator (size 10)
98 : ** - array_declarator (size 20)
99 : ** - array_declarator (size 30)
100 : ** - simple_declarator (name tab3D)
101 : **
102 : **
103 : ** OUTPUT :
104 : ** ========
105 : **
106 : ** (type) contains NULL,
107 : **
108 : ** (decl) contains NULL,
109 : **
110 : ** (resultType) contains :
111 : ** - IDLArrayType (size 30)
112 : ** - IDLArrayType (size 20)
113 : ** - IDLArrayType (size 10)
114 : ** - IDLType (long)
115 : **
116 : ** (return) contains : tab3D
117 : **
118 : ** This describes that :
119 : ** - tab3D
120 : ** - is an array of size 10 of
121 : ** an array of size 20 of
122 : ** an array of size 30 of
123 : ** long
124 : **
125 : */
126 :
127 : static String ReverseTypeDeclaration(
128 : IDLType *& type,
129 : Declarator *& decl,
130 6840 : IDLType *& resultType)
131 : {
132 : ASSERT(type != NULL) ;
133 : ASSERT(decl != NULL) ;
134 :
135 : // WARNING : MUST return by value, not by reference,
136 : // since decl is destroyed (and contained the name in SimpleDeclarator)
137 6840 : String resultName ;
138 :
139 6840 : IDLType *current_type = type ;
140 6840 : type = NULL ;
141 :
142 6840 : Declarator *original_declarator = decl ;
143 6840 : decl = NULL ;
144 :
145 : Declarator *currentDeclarator = original_declarator ;
146 :
147 : SimpleDeclarator *simple = NULL ;
148 : ArrayDeclarator *array = NULL ;
149 : int size ;
150 :
151 13680 : while (currentDeclarator->GetKind() == ArrayDeclaratorKind)
152 : {
153 0 : array = (ArrayDeclarator*) currentDeclarator ;
154 0 : size = array->GetSize() ;
155 :
156 : // Consume one tree element on the right side
157 0 : currentDeclarator = array->GetElement() ;
158 :
159 : // Add one tree element on the left side
160 0 : current_type = new IDLArrayType(size, current_type) ;
161 : }
162 :
163 : ASSERT(currentDeclarator->GetKind() == SimpleDeclaratorKind) ;
164 :
165 : simple = (SimpleDeclarator*) currentDeclarator ;
166 6840 : resultName = simple->GetName() ;
167 6840 : resultType = current_type ;
168 :
169 : // Chain reaction, do this AFTER simple->GetName() !
170 : // this delete destroys completly the right tree.
171 6840 : delete original_declarator ;
172 :
173 0 : return resultName ; // Return by VALUE !
174 : }
175 :
176 6631 : static IDLType *Symbol2Type(Symbol *symbol)
177 : {
178 : IDLType *result = NULL ;
179 :
180 6631 : switch(symbol->GetClass())
181 : {
182 : case moduleSymbol:
183 : {
184 : break ;
185 : }
186 : case interfaceSymbol:
187 : {
188 : Interface *i = (Interface*) symbol ;
189 2322 : result = new IDLInterfaceType(i) ;
190 2322 : break ;
191 : }
192 : case attributeSymbol:
193 : {
194 : break ;
195 : }
196 : case operationSymbol:
197 : {
198 : break ;
199 : }
200 : case parameterSymbol:
201 : {
202 : break ;
203 : }
204 : case typedefSymbol:
205 : {
206 : Typedef *t = (Typedef*) symbol ;
207 3464 : result = new IDLTypedefType(t) ;
208 3464 : break ;
209 : }
210 : case structSymbol:
211 : {
212 : Struct *s = (Struct*) symbol ;
213 422 : result = new IDLStructType(s) ;
214 422 : break ;
215 : }
216 : case memberSymbol:
217 : {
218 : break ;
219 : }
220 : case unionSymbol:
221 : {
222 0 : NON_DEV("IDLType for union symbol") ;
223 0 : break ;
224 : }
225 : case constantSymbol:
226 : {
227 : break ;
228 : }
229 : case enumSymbol:
230 : {
231 : Enum *e = (Enum*) symbol ;
232 389 : result = new IDLEnumType(e) ;
233 389 : break ;
234 : }
235 : case enumItemSymbol:
236 : {
237 : break ;
238 : }
239 : case exceptionSymbol:
240 : {
241 : break ;
242 : }
243 : case nativeSymbol:
244 : {
245 : SymNative *native = (SymNative*) symbol ;
246 28 : result = new IDLNativeType(native) ;
247 : break ;
248 : }
249 : }
250 :
251 6625 : if (result == NULL)
252 : {
253 6 : String error = "Symbol \"" ;
254 6 : error += symbol->GetName() ;
255 6 : error += "\" is not a type." ;
256 6 : IDLCompileError(error) ;
257 6 : result = new IDLErrorType() ;
258 : }
259 :
260 : return result ;
261 : }
262 :
263 : static Interface* InterfaceDeclaration(
264 : InterfaceAttribute attr,
265 : const String& name,
266 864 : ScopeList *inherit)
267 : {
268 : ASSERT(inherit != NULL) ;
269 :
270 : // ============================== PART 1 : check any forward ==============
271 :
272 : Symbol *symbol = NULL ;
273 :
274 864 : symbol = g_symTabPtr->findLocalSymbol(name) ;
275 :
276 : Interface *interface = NULL ;
277 :
278 864 : if (symbol == NULL)
279 : {
280 390 : interface = new Interface(attr, name) ;
281 390 : g_symTabPtr->addSymbol(interface) ;
282 : }
283 : else
284 : {
285 474 : if (symbol->GetClass() == interfaceSymbol)
286 : {
287 474 : interface = (Interface*) symbol ;
288 474 : InterfaceAttribute attr2 = interface->GetAttribute() ;
289 :
290 474 : if (attr != attr2)
291 : {
292 1 : String error = "Interface declaration \"" ;
293 1 : error += name ;
294 1 : error += "\" conflicts with previous forward declarations." ;
295 1 : IDLCompileError(error) ;
296 : }
297 :
298 : // Relocate the entry in last position
299 : // in the symbol table,
300 : // so that the symbol table is
301 : // ORDERED BY DEFINITION (not DECLARATION)
302 :
303 474 : g_symTabPtr->relocateTail(interface) ;
304 :
305 : }
306 : else
307 : {
308 0 : NON_DEV("Error Message") ;
309 0 : return NULL ;
310 : }
311 : }
312 :
313 : // ============================== PART 2 : add inheritance =================
314 :
315 864 : if (interface->IsDefined())
316 : {
317 1 : String error = "Interface \"" ;
318 1 : error += name ;
319 1 : error += "\" is already defined in this scope." ;
320 1 : IDLCompileError(error) ;
321 :
322 1 : return interface ;
323 : }
324 :
325 863 : interface->Define() ;
326 :
327 : ScopeListIt it(*inherit) ;
328 : Scope *scopeInherit = NULL ;
329 : Interface *super = NULL ;
330 :
331 2409 : while (it.GetNext())
332 : {
333 : scopeInherit = it.GetItem() ;
334 683 : symbol = g_symTabPtr->findSymbol(*scopeInherit) ;
335 :
336 683 : if (symbol == NULL)
337 : {
338 1 : String error = "Unknown interface." ;
339 1 : IDLCompileError(error) ;
340 1 : scopeInherit->print(errLog) ;
341 1 : errLog << std::endl ;
342 : }
343 : else
344 : {
345 682 : if (symbol->GetClass() == interfaceSymbol)
346 : {
347 : super = (Interface*) symbol ;
348 681 : interface->addInheritance(super) ;
349 : }
350 : else
351 : {
352 1 : NON_DEV("Error message: not an interface") ;
353 : }
354 : }
355 : }
356 :
357 : return interface ;
358 : }
359 :
360 : static void ForwardInterface(
361 : InterfaceAttribute attr,
362 477 : const String& name)
363 : {
364 477 : String *nameCopy = new String(name) ;
365 477 : Scope scope(false, nameCopy) ;
366 :
367 477 : Symbol *symbol = g_symTabPtr->findSymbol(scope) ;
368 :
369 : Interface *interface = NULL ;
370 :
371 477 : if (symbol == NULL)
372 : {
373 475 : interface = new Interface(attr, name) ;
374 475 : g_symTabPtr->addSymbol(interface) ;
375 : }
376 : else
377 : {
378 2 : if (symbol->GetClass() == interfaceSymbol)
379 : {
380 : interface = (Interface*) symbol ;
381 1 : InterfaceAttribute attr2 = interface->GetAttribute() ;
382 :
383 1 : if (attr != attr2)
384 : {
385 1 : String error = "Interface declaration \"" ;
386 1 : error += name ;
387 1 : error += "\" conflicts with previous forward declarations." ;
388 1 : IDLCompileError(error) ;
389 : }
390 : }
391 : else
392 : {
393 1 : NON_DEV("Error Message") ;
394 : }
395 : }
396 :
397 0 : return ;
398 : }
399 :
400 : %}
401 :
402 : /* Keywords */
403 :
404 : %token TOK_ABSTRACT
405 : %token TOK_ANY
406 : %token TOK_ATTRIBUTE
407 : %token TOK_BOOLEAN
408 : %token TOK_CASE
409 : %token TOK_CHAR
410 : %token TOK_COMPONENT
411 : %token TOK_CONST
412 : %token TOK_CONSUMES
413 : %token TOK_CONTEXT
414 : %token TOK_CUSTOM
415 : %token TOK_DEFAULT
416 : %token TOK_DOUBLE
417 : %token TOK_EMITS
418 : %token TOK_ENUM
419 : %token TOK_EVENTTYPE
420 : %token TOK_EXCEPTION
421 : %token TOK_FACTORY
422 : %token TOK_FINDER
423 : %token TOK_FALSE
424 : %token TOK_FIXED
425 : %token TOK_FLOAT
426 : %token TOK_GETRAISES
427 : %token TOK_HOME
428 : %token TOK_IMPORT
429 : %token TOK_IN
430 : %token TOK_INOUT
431 : %token TOK_INTERFACE
432 : %token TOK_LOCAL
433 : %token TOK_LONG
434 : %token TOK_MODULE
435 : %token TOK_MULTIPLE
436 : %token TOK_NATIVE
437 : %token TOK_OBJECT
438 : %token TOK_OCTET
439 : %token TOK_ONEWAY
440 : %token TOK_OUT
441 : %token TOK_PRIMARYKEY
442 : %token TOK_PRIVATE
443 : %token TOK_PROVIDES
444 : %token TOK_PUBLIC
445 : %token TOK_PUBLISHES
446 : %token TOK_RAISES
447 : %token TOK_READONLY
448 : %token TOK_SEQUENCE
449 : %token TOK_SETRAISES
450 : %token TOK_SHORT
451 : %token TOK_STRING
452 : %token TOK_STRUCT
453 : %token TOK_SUPPORTS
454 : %token TOK_SWITCH
455 : %token TOK_TRUE
456 : %token TOK_TRUNCATABLE
457 : %token TOK_TYPEDEF
458 : %token TOK_TYPEID
459 : %token TOK_TYPEPREFIX
460 : %token TOK_UNION
461 : %token TOK_UNSIGNED
462 : %token TOK_USES
463 : %token TOK_VALUEBASE
464 : %token TOK_VALUETYPE
465 : %token TOK_VOID
466 : %token TOK_WCHAR
467 : %token TOK_WSTRING
468 :
469 : /* Punctuation */
470 :
471 : %token TOK_SEMICOLON
472 : %token TOK_LEFT_CURLY_BRAKET
473 : %token TOK_RIGHT_CURLY_BRAKET
474 : %token TOK_COLON
475 : %token TOK_COMMA
476 : %token TOK_EQUALS
477 : %token TOK_PLUS
478 : %token TOK_MINUS
479 : %token TOK_LEFT_PARENTHESIS
480 : %token TOK_RIGHT_PARENTHESIS
481 : %token TOK_LESS_THAN
482 : %token TOK_GREATER_THAN
483 : %token TOK_LEFT_SQUARE_BRAKET
484 : %token TOK_RIGHT_SQUARE_BRAKET
485 : %token TOK_VERTICAL_LINE
486 : %token TOK_CIRCUMFLEX
487 : %token TOK_AMPERSAND
488 : %token TOK_ASTERISK
489 : %token TOK_SOLIDUS
490 : %token TOK_PERCENT
491 : %token TOK_TILDE
492 :
493 :
494 : %token TOK_IDENTIFIER
495 : %token integer_literal
496 : %token string_literal_unit
497 : %token wide_string_literal_unit
498 : %token character_literal
499 : %token wide_character_literal
500 : %token fixed_pt_literal
501 : %token floating_pt_literal
502 :
503 : /* Operators */
504 :
505 : %token TOK_DOUBLE_SEMICOLON
506 : %token TOK_SHIFT_LEFT
507 : %token TOK_SHIFT_RIGHT
508 :
509 : /* FIXME : to investigate if real keyword or not */
510 : %token TOK_MANAGES
511 :
512 : /* Type of $$ */
513 :
514 : %union
515 : {
516 : String *StringPtr ;
517 : StringList *StringListPtr ;
518 : WString *WStringPtr ;
519 : IDLConstExp *ConstExpPtr ;
520 : IDLType* TypePtr;
521 : Scope *ScopePtr;
522 : ScopeList *ScopeListPtr;
523 : Member *MemberPtr;
524 : MemberList *MemberListPtr;
525 : Declarator *DeclaratorPtr ;
526 : DeclaratorList *DeclaratorListPtr ;
527 : SimpleDeclarator *SimpleDeclaratorPtr ;
528 : SimpleDeclaratorList *SimpleDeclaratorListPtr ;
529 : ParameterAttribute ParamAttributeEnum ;
530 : Parameter *ParameterPtr ;
531 : ParameterList *ParameterListPtr ;
532 : OperationAttribute OpAttributeEnum ;
533 : Interface *InterfacePtr ;
534 : idlSize sizeValue ;
535 : void *NOTHING;
536 : }
537 :
538 :
539 : %type <StringPtr> TOK_IDENTIFIER
540 : %type <StringPtr> string_literal_unit
541 : %type <StringPtr> string_literal
542 : %type <StringPtr> enumerator
543 :
544 : %type <StringListPtr> enumerator_lst
545 : %type <StringListPtr> string_literal_lst
546 : %type <StringListPtr> context_expr
547 : %type <StringListPtr> context_expr_opt
548 :
549 : %type <WStringPtr> wide_string_literal_unit
550 : %type <WStringPtr> wide_string_literal
551 :
552 : %type <ConstExpPtr> const_exp
553 : %type <ConstExpPtr> or_exp
554 : %type <ConstExpPtr> xor_exp
555 : %type <ConstExpPtr> and_exp
556 : %type <ConstExpPtr> shift_exp
557 : %type <ConstExpPtr> add_exp
558 : %type <ConstExpPtr> mult_exp
559 : %type <ConstExpPtr> unary_exp
560 : %type <ConstExpPtr> primary_exp
561 : %type <ConstExpPtr> literal
562 : %type <ConstExpPtr> integer_literal
563 : %type <ConstExpPtr> character_literal
564 : %type <ConstExpPtr> wide_character_literal
565 : %type <ConstExpPtr> fixed_pt_literal
566 : %type <ConstExpPtr> floating_pt_literal
567 : %type <ConstExpPtr> boolean_literal
568 :
569 : %type <TypePtr> const_type
570 : %type <TypePtr> simple_type_spec
571 : %type <TypePtr> base_type_spec
572 : %type <TypePtr> template_type_spec
573 : %type <TypePtr> floating_pt_type
574 : %type <TypePtr> integer_type
575 : %type <TypePtr> signed_int
576 : %type <TypePtr> signed_short_int
577 : %type <TypePtr> signed_long_int
578 : %type <TypePtr> signed_longlong_int
579 : %type <TypePtr> unsigned_int
580 : %type <TypePtr> unsigned_short_int
581 : %type <TypePtr> unsigned_long_int
582 : %type <TypePtr> unsigned_longlong_int
583 : %type <TypePtr> char_type
584 : %type <TypePtr> wide_char_type
585 : %type <TypePtr> boolean_type
586 : %type <TypePtr> octet_type
587 : %type <TypePtr> any_type
588 : %type <TypePtr> object_type
589 : %type <TypePtr> string_type
590 : %type <TypePtr> wide_string_type
591 : %type <TypePtr> fixed_pt_const_type
592 : %type <TypePtr> fixed_pt_type
593 : %type <TypePtr> switch_type_spec
594 : %type <TypePtr> sequence_type
595 : %type <TypePtr> param_type_spec
596 : %type <TypePtr> struct_type
597 : %type <TypePtr> enum_type
598 : %type <TypePtr> union_type
599 : %type <TypePtr> op_type_spec
600 : %type <TypePtr> constr_type_spec
601 : %type <TypePtr> type_spec
602 : %type <TypePtr> value_base_type
603 :
604 : %type <ScopePtr> scoped_name
605 : %type <ScopePtr> interface_name
606 :
607 : %type <ScopeListPtr> scoped_name_lst
608 : %type <ScopeListPtr> interface_name_lst
609 : %type <ScopeListPtr> interface_inheritance_spec
610 : %type <ScopeListPtr> interface_inheritance_spec_opt
611 : %type <ScopeListPtr> raises_expr
612 : %type <ScopeListPtr> raises_expr_opt
613 :
614 : %type <MemberPtr> member
615 :
616 : %type <MemberListPtr> member_list
617 : %type <MemberListPtr> member_lst_opt
618 :
619 : %type <DeclaratorPtr> declarator
620 : %type <DeclaratorPtr> complex_declarator
621 : %type <DeclaratorPtr> array_declarator
622 : %type <DeclaratorListPtr> declarators
623 :
624 : %type <SimpleDeclaratorPtr> simple_declarator
625 : %type <SimpleDeclaratorListPtr> simple_declarator_lst
626 : %type <SimpleDeclaratorListPtr> attr_declarator
627 : %type <SimpleDeclaratorListPtr> readonly_attr_declarator
628 :
629 : %type <ParamAttributeEnum> param_attribute
630 : %type <ParamAttributeEnum> init_param_attribute
631 :
632 : %type <ParameterPtr> param_dcl
633 :
634 : %type <ParameterListPtr> param_dcl_lst
635 : %type <ParameterListPtr> parameter_dcls
636 :
637 : %type <OpAttributeEnum> op_attribute_opt ;
638 : %type <OpAttributeEnum> op_attribute ;
639 :
640 : %type <InterfacePtr> interface_header
641 :
642 :
643 : %type <NOTHING> specification
644 : %type <NOTHING> import_lst_opt
645 : %type <NOTHING> import
646 : %type <NOTHING> definition_lst
647 : %type <NOTHING> definition
648 : %type <NOTHING> export
649 : %type <NOTHING> type_dcl
650 : %type <NOTHING> const_dcl
651 : %type <NOTHING> except_dcl
652 : %type <NOTHING> module
653 : %type <NOTHING> interface_dcl
654 : %type <NOTHING> forward_dcl
655 : %type <NOTHING> interface
656 : %type <NOTHING> attr_dcl
657 : %type <NOTHING> readonly_attr_spec
658 : %type <NOTHING> attr_spec
659 : %type <NOTHING> op_dcl
660 :
661 : %type <sizeValue> positive_int_const
662 :
663 :
664 : /* FIXME : not implemented */
665 : %type <NOTHING> imported_scope
666 : %type <NOTHING> type_id_dcl
667 : %type <NOTHING> type_prefix_dcl
668 :
669 :
670 : %%
671 : /* IDL Grammar */
672 :
673 : /* OMG Rule (1-a) */
674 :
675 : specification
676 : : import_lst_opt
677 : definition_lst
678 : /* No actions */
679 : ;
680 :
681 : /* OMG Rule (1-b) */
682 :
683 : import_lst_opt
684 : : /* empty */
685 : {
686 : /* No actions */
687 48 : $$ = NULL ;
688 : }
689 48 : | import_lst_opt import
690 : /* No actions */
691 : ;
692 :
693 : /* OMG Rule (1-c) */
694 :
695 : definition_lst
696 : : definition
697 : /* No actions */
698 : | definition_lst definition
699 : /* No actions */
700 : ;
701 :
702 : /* OMG Rule (2) */
703 :
704 : definition
705 : : type_dcl TOK_SEMICOLON
706 : /* No actions */
707 : | const_dcl TOK_SEMICOLON
708 : /* No actions */
709 : | except_dcl TOK_SEMICOLON
710 : /* No actions */
711 : | interface TOK_SEMICOLON
712 : /* No actions */
713 : | module TOK_SEMICOLON
714 : /* No actions */
715 : | value TOK_SEMICOLON
716 : {
717 5 : NON_DEV("definition = value") ;
718 : }
719 5 : | type_id_dcl TOK_SEMICOLON
720 : {
721 0 : NON_DEV("definition") ;
722 : }
723 0 : | type_prefix_dcl TOK_SEMICOLON
724 : {
725 0 : NON_DEV("definition") ;
726 : }
727 0 : | event TOK_SEMICOLON
728 : {
729 0 : NON_DEV("definition") ;
730 : }
731 0 : | component TOK_SEMICOLON
732 : {
733 0 : NON_DEV("definition") ;
734 : }
735 0 : | home_dcl TOK_SEMICOLON
736 : {
737 0 : NON_DEV("definition") ;
738 : }
739 0 : | error TOK_SEMICOLON
740 : {
741 : /* Error recovery : just to use YYERROR **once** */
742 : /* to avoid warnings about yyerrlab1: in the generated code */
743 : YYERROR ;
744 : }
745 : ;
746 :
747 : /* OMG Rule (3) */
748 :
749 : module
750 : : TOK_MODULE
751 : TOK_IDENTIFIER
752 : {
753 110 : String *moduleName = $2 ;
754 : ASSERT(moduleName != NULL) ;
755 110 : Module *module = new Module(*moduleName) ;
756 110 : g_symTabPtr->addSymbol(module) ;
757 :
758 110 : g_symTabPtr->openContext(*moduleName) ;
759 : }
760 110 : TOK_LEFT_CURLY_BRAKET definition_lst TOK_RIGHT_CURLY_BRAKET
761 : {
762 109 : g_symTabPtr->closeContext() ;
763 : }
764 109 : ;
765 :
766 : /* OMG Rule (4) */
767 :
768 : interface
769 : : interface_dcl
770 : /* No actions */
771 : | forward_dcl
772 : /* No actions */
773 : ;
774 :
775 : /* OMG Rule (5) */
776 :
777 : interface_dcl
778 : : interface_header
779 : {
780 : Interface *interface = $1 ;
781 864 : String name = interface->GetName() ;
782 864 : g_symTabPtr->openContext(name) ;
783 : }
784 864 : TOK_LEFT_CURLY_BRAKET interface_body TOK_RIGHT_CURLY_BRAKET
785 : {
786 863 : g_symTabPtr->closeContext() ;
787 : }
788 863 : ;
789 :
790 : /* OMG Rule (6) */
791 :
792 : forward_dcl
793 : : TOK_ABSTRACT TOK_INTERFACE TOK_IDENTIFIER
794 : {
795 1 : String *name = $3 ;
796 : ASSERT(name != NULL) ;
797 :
798 1 : ForwardInterface(INTERFACE_ABSTRACT, *name) ;
799 1 : delete name ;
800 : }
801 : | TOK_LOCAL TOK_INTERFACE TOK_IDENTIFIER
802 : {
803 0 : String *name = $3 ;
804 : ASSERT(name != NULL) ;
805 :
806 0 : ForwardInterface(INTERFACE_LOCAL, *name) ;
807 0 : delete name ;
808 : }
809 : | TOK_INTERFACE TOK_IDENTIFIER
810 : {
811 476 : String *name = $2 ;
812 : ASSERT(name != NULL) ;
813 :
814 476 : ForwardInterface(INTERFACE_NORMAL, *name) ;
815 476 : delete name ;
816 : }
817 : ;
818 :
819 : /* OMG Rule (7-a) */
820 :
821 : interface_header
822 : : TOK_ABSTRACT TOK_INTERFACE TOK_IDENTIFIER interface_inheritance_spec_opt
823 : {
824 1 : String *name = $3 ;
825 1 : ScopeList *inheritance = $4 ;
826 : ASSERT(name != NULL) ;
827 : ASSERT(inheritance != NULL) ;
828 :
829 : $$ = InterfaceDeclaration(INTERFACE_ABSTRACT,
830 : *name,
831 1 : inheritance) ;
832 :
833 : inheritance->clearAndDestroy() ;
834 2 : delete inheritance ;
835 :
836 1 : delete name ;
837 : }
838 : | TOK_LOCAL TOK_INTERFACE TOK_IDENTIFIER interface_inheritance_spec_opt
839 : {
840 0 : String *name = $3 ;
841 0 : ScopeList *inheritance = $4 ;
842 : ASSERT(name != NULL) ;
843 : ASSERT(inheritance != NULL) ;
844 :
845 : $$ = InterfaceDeclaration(INTERFACE_LOCAL,
846 : *name,
847 0 : inheritance) ;
848 :
849 : inheritance->clearAndDestroy() ;
850 0 : delete inheritance ;
851 :
852 0 : delete name ;
853 : }
854 : | TOK_INTERFACE TOK_IDENTIFIER interface_inheritance_spec_opt
855 : {
856 863 : String *name = $2 ;
857 863 : ScopeList *inheritance = $3 ;
858 : ASSERT(name != NULL) ;
859 : ASSERT(inheritance != NULL) ;
860 :
861 : $$ = InterfaceDeclaration(INTERFACE_NORMAL,
862 : *name,
863 863 : inheritance) ;
864 :
865 : inheritance->clearAndDestroy() ;
866 1726 : delete inheritance ;
867 :
868 863 : delete name ;
869 : }
870 : ;
871 :
872 : /* OMG Rule (7-b) */
873 :
874 : interface_inheritance_spec_opt
875 : : /* empty */
876 : {
877 335 : $$ = new ScopeList() ;
878 : }
879 335 : | interface_inheritance_spec
880 : {
881 529 : $$ = $1 ;
882 : }
883 529 : ;
884 :
885 : /* OMG Rule (8-a) */
886 :
887 : interface_body
888 : : export_lst_opt
889 : /* No actions */
890 : ;
891 :
892 : /* OMG Rule (8-b) */
893 :
894 : export_lst_opt
895 : : /* empty */
896 : /* No actions */
897 : | export_lst_opt export
898 : /* No actions */
899 : ;
900 :
901 : /* OMG Rule (9) */
902 :
903 : export
904 : : type_dcl TOK_SEMICOLON
905 : /* No actions */
906 : | const_dcl TOK_SEMICOLON
907 : /* No actions */
908 : | except_dcl TOK_SEMICOLON
909 : /* No actions */
910 : | attr_dcl TOK_SEMICOLON
911 : /* No actions */
912 : | op_dcl TOK_SEMICOLON
913 : /* No actions */
914 : | type_id_dcl TOK_SEMICOLON
915 : /* No actions */
916 : | type_prefix_dcl TOK_SEMICOLON
917 : /* No actions */
918 : ;
919 :
920 : /* OMG Rule (10-a) */
921 :
922 : interface_inheritance_spec
923 : : TOK_COLON interface_name_lst
924 : {
925 529 : $$ = $2 ;
926 : }
927 529 : ;
928 :
929 : /* OMG Rule (10-b) */
930 :
931 : interface_name_lst
932 : : interface_name
933 : {
934 529 : $$ = new ScopeList($1) ;
935 : }
936 529 : | interface_name_lst TOK_COMMA interface_name
937 : {
938 154 : $1->addTail($3) ;
939 154 : $$ = $1 ;
940 : }
941 154 : ;
942 :
943 : /* OMG Rule (11) */
944 : interface_name
945 : : scoped_name
946 : {
947 683 : $$ = $1 ;
948 : }
949 683 : ;
950 :
951 : /* OMG Rule (12) */
952 :
953 : scoped_name
954 : : TOK_IDENTIFIER
955 : {
956 8879 : $$ = new Scope(false, $1) ;
957 : }
958 8879 : | TOK_DOUBLE_SEMICOLON TOK_IDENTIFIER
959 : {
960 0 : $$ = new Scope(true, $2) ;
961 : }
962 0 : | scoped_name TOK_DOUBLE_SEMICOLON TOK_IDENTIFIER
963 : {
964 488 : $1->AppendName($3) ;
965 488 : $$ = $1 ;
966 : }
967 488 : ;
968 :
969 : /* OMG Rule (13) */
970 :
971 : value
972 : : value_dcl
973 : {
974 1 : NON_DEV("value") ;
975 : }
976 1 : | value_abs_dcl
977 : {
978 1 : NON_DEV("value") ;
979 : }
980 1 : | value_box_dcl
981 : {
982 1 : NON_DEV("value") ;
983 : }
984 1 : | value_forward_dcl
985 : {
986 2 : NON_DEV("value") ;
987 : }
988 2 : ;
989 :
990 : /* OMG Rule (14) */
991 :
992 : value_forward_dcl
993 : : TOK_ABSTRACT TOK_VALUETYPE TOK_IDENTIFIER
994 : {
995 1 : NON_DEV("value_forward_dcl") ;
996 : }
997 1 : | TOK_VALUETYPE TOK_IDENTIFIER
998 : {
999 1 : NON_DEV("value_forward_dcl") ;
1000 : }
1001 1 : ;
1002 :
1003 : /* OMG Rule (15) */
1004 :
1005 : value_box_dcl
1006 : : TOK_VALUETYPE TOK_IDENTIFIER type_spec
1007 : {
1008 1 : NON_DEV("value_box_dcl") ;
1009 : }
1010 1 : ;
1011 :
1012 : /* OMG Rule (16-a) */
1013 :
1014 : value_abs_dcl
1015 : : TOK_ABSTRACT TOK_VALUETYPE TOK_IDENTIFIER value_inheritance_spec_opt
1016 : TOK_LEFT_CURLY_BRAKET export_lst_opt TOK_RIGHT_CURLY_BRAKET
1017 : {
1018 1 : NON_DEV("value_abs_dcl") ;
1019 : }
1020 1 : ;
1021 :
1022 : /* OMG Rule (16-b) */
1023 :
1024 : value_inheritance_spec_opt
1025 : : /* empty */
1026 : {
1027 2 : NON_DEV("value_inheritance_spec_opt") ;
1028 : }
1029 2 : | value_inheritance_spec
1030 : {
1031 0 : NON_DEV("value_inheritance_spec_opt") ;
1032 : }
1033 0 : ;
1034 :
1035 : /* OMG Rule (17-a) */
1036 :
1037 : value_dcl
1038 : : value_header
1039 : TOK_LEFT_CURLY_BRAKET value_element_lst_opt TOK_RIGHT_CURLY_BRAKET
1040 : {
1041 1 : NON_DEV("value_dcl") ;
1042 : }
1043 1 : ;
1044 :
1045 : /* OMG Rule (17-b) */
1046 :
1047 : value_element_lst_opt
1048 : : /* empty */
1049 : {
1050 1 : NON_DEV("value_element_lst_opt") ;
1051 : }
1052 1 : | value_element_lst_opt TOK_COMMA value_element
1053 : {
1054 0 : NON_DEV("value_element_lst_opt") ;
1055 : }
1056 0 : ;
1057 :
1058 : /* OMG Rule (18) */
1059 :
1060 : value_header
1061 : : TOK_CUSTOM TOK_VALUETYPE TOK_IDENTIFIER value_inheritance_spec_opt
1062 : {
1063 1 : NON_DEV("value_header") ;
1064 : }
1065 1 : | TOK_VALUETYPE TOK_IDENTIFIER value_inheritance_spec_opt
1066 : {
1067 0 : NON_DEV("value_header") ;
1068 : }
1069 0 : ;
1070 :
1071 : /* OMG Rule (19-a) : FIXME, bogus grammar */
1072 :
1073 : value_inheritance_spec
1074 : : TOK_COLON TOK_TRUNCATABLE value_name_lst
1075 : {
1076 0 : NON_DEV("value_inheritance_spec") ;
1077 : }
1078 0 : | TOK_COLON value_name_lst
1079 : {
1080 0 : NON_DEV("value_inheritance_spec") ;
1081 : }
1082 0 : /*
1083 : ** | TOK_SUPPORTS interface_name_lst
1084 : ** {
1085 : ** NON_DEV("value_inheritance_spec") ;
1086 : ** }
1087 : */
1088 : ;
1089 :
1090 : /* OMG Rule (19-b) */
1091 :
1092 : value_name_lst
1093 : : value_name
1094 : {
1095 0 : NON_DEV("value_name_lst") ;
1096 : }
1097 0 : | value_name_lst TOK_COMMA value_name
1098 : {
1099 0 : NON_DEV("value_name_lst") ;
1100 : }
1101 0 : ;
1102 :
1103 : /* OMG Rule (20) */
1104 :
1105 : value_name
1106 : : scoped_name
1107 : {
1108 0 : NON_DEV("value_name") ;
1109 : }
1110 0 : ;
1111 :
1112 :
1113 : /* OMG Rule (21) */
1114 :
1115 : value_element
1116 : : export
1117 : {
1118 0 : NON_DEV("value_element") ;
1119 : }
1120 0 : | state_member
1121 : {
1122 0 : NON_DEV("value_element") ;
1123 : }
1124 0 : | init_dcl
1125 : {
1126 0 : NON_DEV("value_element") ;
1127 : }
1128 0 : ;
1129 :
1130 : /* OMG Rule (22) */
1131 :
1132 : state_member
1133 : : TOK_PUBLIC type_spec declarators TOK_SEMICOLON
1134 : {
1135 0 : NON_DEV("state_member") ;
1136 : }
1137 0 : | TOK_PRIVATE type_spec declarators TOK_SEMICOLON
1138 : {
1139 0 : NON_DEV("state_member") ;
1140 : }
1141 0 : ;
1142 :
1143 : /* OMG Rule (23-a) */
1144 :
1145 : init_dcl
1146 : : TOK_FACTORY TOK_IDENTIFIER
1147 : TOK_LEFT_PARENTHESIS init_param_decls_opt TOK_RIGHT_PARENTHESIS
1148 : raises_expr_opt
1149 : TOK_SEMICOLON
1150 : {
1151 0 : NON_DEV("init_dcl") ;
1152 : }
1153 0 : ;
1154 :
1155 : /* OMG Rule (23-b) */
1156 :
1157 : init_param_decls_opt
1158 : : /* empty */
1159 : {
1160 0 : NON_DEV("init_param_decls_opt") ;
1161 : }
1162 0 : | init_param_decls
1163 : {
1164 0 : NON_DEV("init_param_decls_opt") ;
1165 : }
1166 0 : ;
1167 :
1168 : /* OMG Rule (24) */
1169 :
1170 : init_param_decls
1171 : : init_param_decl
1172 : {
1173 0 : NON_DEV("init_param_decls") ;
1174 : }
1175 0 : | init_param_decls TOK_COMMA init_param_decl
1176 : {
1177 0 : NON_DEV("init_param_decls") ;
1178 : }
1179 0 : ;
1180 :
1181 : /* OMG Rule (25) */
1182 :
1183 : init_param_decl
1184 : : init_param_attribute param_type_spec simple_declarator
1185 : {
1186 0 : NON_DEV("init_param_decl") ;
1187 : }
1188 0 : ;
1189 :
1190 : /* OMG Rule (26) */
1191 :
1192 : init_param_attribute
1193 : : TOK_IN
1194 : {
1195 0 : $$ = PARAMETER_IN ;
1196 : }
1197 0 : ;
1198 :
1199 : /* OMG Rule (27) */
1200 :
1201 : const_dcl
1202 : : TOK_CONST const_type TOK_IDENTIFIER TOK_EQUALS const_exp
1203 : {
1204 605 : IDLType *type = $2 ;
1205 605 : String *name = $3 ;
1206 605 : IDLConstExp *exp = $5 ;
1207 :
1208 : ASSERT(type != NULL) ;
1209 : ASSERT(name != NULL) ;
1210 : ASSERT(exp != NULL) ;
1211 :
1212 605 : IDLValue *value = exp->evaluate(type) ;
1213 :
1214 605 : Constant *constant = new Constant(*name, value) ;
1215 :
1216 : ASSERT(g_symTabPtr != NULL) ;
1217 605 : g_symTabPtr->addSymbol(constant) ;
1218 :
1219 605 : delete name ;
1220 605 : delete exp ;
1221 605 : delete type ;
1222 : }
1223 : ;
1224 :
1225 : /* OMG Rule (28) */
1226 :
1227 : const_type
1228 : : integer_type
1229 : {
1230 449 : $$ = $1 ;
1231 : }
1232 449 : | char_type
1233 : {
1234 18 : $$ = $1 ;
1235 : }
1236 18 : | wide_char_type
1237 : {
1238 16 : $$ = $1 ;
1239 : }
1240 16 : | boolean_type
1241 : {
1242 0 : $$ = $1 ;
1243 : }
1244 0 : | floating_pt_type
1245 : {
1246 12 : $$ = $1 ;
1247 : }
1248 12 : | string_type
1249 : {
1250 1 : $$ = $1 ;
1251 : }
1252 1 : | wide_string_type
1253 : {
1254 1 : $$ = $1 ;
1255 : }
1256 1 : | fixed_pt_const_type
1257 : {
1258 0 : $$ = $1 ;
1259 : }
1260 0 : | scoped_name
1261 : {
1262 104 : Scope *scope = $1 ;
1263 104 : Symbol *symbol = g_symTabPtr->findSymbol(*scope) ;
1264 :
1265 104 : if (symbol == NULL)
1266 : {
1267 0 : String error = "Undefined symbol " ;
1268 0 : error += scope->GetFullName() ;
1269 0 : IDLCompileError(error) ;
1270 :
1271 0 : $$ = new IDLErrorType() ;
1272 : }
1273 : else
1274 : {
1275 104 : if (symbol->GetClass() != typedefSymbol)
1276 : {
1277 0 : NON_DEV("check symbol is a typedef") ;
1278 0 : $$ = new IDLErrorType() ;
1279 : }
1280 : else
1281 : {
1282 : Typedef *t = (Typedef*) symbol ;
1283 104 : $$ = new IDLTypedefType(t) ;
1284 : }
1285 : }
1286 : }
1287 : | octet_type
1288 : {
1289 4 : $$ = $1 ;
1290 : }
1291 4 : ;
1292 :
1293 : /* OMG Rule (29) */
1294 :
1295 : const_exp
1296 : : or_exp
1297 : {
1298 605 : $$ = $1 ;
1299 : }
1300 605 : ;
1301 :
1302 : /* OMG Rule (30) */
1303 :
1304 : or_exp
1305 : : xor_exp
1306 : {
1307 605 : $$ = $1 ;
1308 : }
1309 605 : | or_exp TOK_VERTICAL_LINE xor_exp
1310 : {
1311 8 : $$ = new IDLBinaryExp($1, idl_or, $3) ;
1312 : }
1313 8 : ;
1314 :
1315 : /* OMG Rule (31) */
1316 :
1317 : xor_exp
1318 : : and_exp
1319 : {
1320 613 : $$ = $1 ;
1321 : }
1322 613 : | xor_exp TOK_CIRCUMFLEX and_exp
1323 : {
1324 8 : $$ = new IDLBinaryExp($1, idl_xor, $3) ;
1325 : }
1326 8 : ;
1327 :
1328 : /* OMG Rule (32) */
1329 :
1330 : and_exp
1331 : : shift_exp
1332 : {
1333 621 : $$ = $1 ;
1334 : }
1335 621 : | and_exp TOK_AMPERSAND shift_exp
1336 : {
1337 8 : $$ = new IDLBinaryExp($1, idl_and, $3) ;
1338 : }
1339 8 : ;
1340 :
1341 : /* OMG Rule (33) */
1342 :
1343 : shift_exp
1344 : : add_exp
1345 : {
1346 629 : $$ = $1 ;
1347 : }
1348 629 : | shift_exp TOK_SHIFT_RIGHT add_exp
1349 : {
1350 8 : $$ = new IDLBinaryExp($1, idl_shr, $3) ;
1351 : }
1352 8 : | shift_exp TOK_SHIFT_LEFT add_exp
1353 : {
1354 59 : $$ = new IDLBinaryExp($1, idl_shl, $3) ;
1355 : }
1356 59 : ;
1357 :
1358 : /* OMG Rule (34) */
1359 :
1360 : add_exp
1361 : : mult_exp
1362 : {
1363 696 : $$ = $1 ;
1364 : }
1365 696 : | add_exp TOK_PLUS mult_exp
1366 : {
1367 30 : $$ = new IDLBinaryExp($1, idl_add, $3) ;
1368 : }
1369 30 : | add_exp TOK_MINUS mult_exp
1370 : {
1371 29 : $$ = new IDLBinaryExp($1, idl_sub, $3) ;
1372 : }
1373 29 : ;
1374 :
1375 : /* OMG Rule (35) */
1376 :
1377 : mult_exp
1378 : : unary_exp
1379 : {
1380 755 : $$ = $1 ;
1381 : }
1382 755 : | mult_exp TOK_ASTERISK unary_exp
1383 : {
1384 11 : $$ = new IDLBinaryExp($1, idl_mul, $3) ;
1385 : }
1386 11 : | mult_exp TOK_SOLIDUS unary_exp
1387 : {
1388 11 : $$ = new IDLBinaryExp($1, idl_div, $3) ;
1389 : }
1390 11 : | mult_exp TOK_PERCENT unary_exp
1391 : {
1392 8 : $$ = new IDLBinaryExp($1, idl_mod, $3) ;
1393 : }
1394 8 : ;
1395 :
1396 : /* OMG Rule (36) + OMG Rule (37) expanded */
1397 :
1398 : unary_exp
1399 : : TOK_PLUS primary_exp
1400 : {
1401 6 : $$ = $2 ;
1402 : }
1403 6 : | TOK_MINUS primary_exp
1404 : {
1405 67 : $$ = new IDLUnaryExp(idl_unary_minus, $2) ;
1406 : }
1407 67 : | TOK_TILDE primary_exp
1408 : {
1409 8 : $$ = new IDLUnaryExp(idl_unary_neg, $2) ;
1410 : }
1411 8 : | primary_exp
1412 : {
1413 704 : $$ = $1 ;
1414 : }
1415 704 : ;
1416 :
1417 : /* OMG Rule (37) */
1418 : /*
1419 : * unary_operator
1420 : * : TOK_MINUS
1421 : * | TOK_PLUS
1422 : * | TOK_TILDE
1423 : * ;
1424 : */
1425 :
1426 : /* OMG Rule (38) */
1427 :
1428 : primary_exp
1429 : : scoped_name
1430 : {
1431 282 : Scope *scope = $1 ;
1432 : ASSERT(scope != NULL) ;
1433 :
1434 282 : Symbol *symbol = g_symTabPtr->findSymbol(*scope) ;
1435 :
1436 282 : if (symbol == NULL)
1437 : {
1438 0 : String error = "Undefined symbol " ;
1439 0 : error += scope->GetFullName() ;
1440 0 : IDLCompileError(error) ;
1441 :
1442 0 : IDLValue * v = new IDLIntValue() ;
1443 0 : $$ = new IDLValueExp(v) ;
1444 : }
1445 : else
1446 : {
1447 282 : switch(symbol->GetClass())
1448 : {
1449 : case constantSymbol :
1450 : {
1451 : Constant * c = (Constant*) symbol ;
1452 282 : IDLValue * v = c->GetValue() ;
1453 282 : $$ = new IDLValueExp(v) ;
1454 282 : break ;
1455 : }
1456 : case enumItemSymbol :
1457 : {
1458 0 : NON_DEV("enum item as a constant") ;
1459 :
1460 0 : IDLValue * v = new IDLIntValue() ;
1461 0 : $$ = new IDLValueExp(v) ;
1462 0 : break ;
1463 : }
1464 : default :
1465 : {
1466 0 : IDLCompileError("Symbol is not a constant") ;
1467 0 : scope->print(errLog) ;
1468 : errLog << std::endl ;
1469 :
1470 0 : IDLValue * v = new IDLIntValue() ;
1471 0 : $$ = new IDLValueExp(v) ;
1472 : }
1473 : }
1474 : }
1475 : }
1476 : | literal
1477 : {
1478 503 : $$ = $1 ;
1479 : }
1480 503 : | TOK_LEFT_PARENTHESIS const_exp TOK_RIGHT_PARENTHESIS
1481 : {
1482 0 : $$ = $2 ;
1483 : }
1484 0 : ;
1485 :
1486 : /* OMG Rule (39) */
1487 :
1488 : literal
1489 : : integer_literal
1490 : {
1491 466 : $$ = $1 ;
1492 : }
1493 466 : | string_literal
1494 : {
1495 4 : String *str = $1 ;
1496 : ASSERT(str != NULL) ;
1497 4 : $$ = new IDLValueExp(new IDLStringValue(*str)) ;
1498 : }
1499 4 : | wide_string_literal
1500 : {
1501 1 : WString *str = $1 ;
1502 : ASSERT(str != NULL) ;
1503 1 : $$ = new IDLValueExp(new IDLWStringValue(*str)) ;
1504 : }
1505 1 : | character_literal
1506 : {
1507 5 : $$ = $1 ;
1508 : }
1509 5 : | wide_character_literal
1510 : {
1511 3 : $$ = $1 ;
1512 : }
1513 3 : | fixed_pt_literal
1514 : {
1515 0 : $$ = $1 ;
1516 : }
1517 0 : | floating_pt_literal
1518 : {
1519 24 : $$ = $1 ;
1520 : }
1521 24 : | boolean_literal
1522 : {
1523 0 : $$ = $1 ;
1524 : }
1525 0 : ;
1526 :
1527 : /* OMG Rule (40) */
1528 :
1529 : boolean_literal
1530 : : TOK_TRUE
1531 : {
1532 0 : IDLValue * v = new IDLBooleanValue(true) ;
1533 0 : $$ = new IDLValueExp(v) ;
1534 : }
1535 0 : | TOK_FALSE
1536 : {
1537 0 : IDLValue * v = new IDLBooleanValue(false) ;
1538 0 : $$ = new IDLValueExp(v) ;
1539 : }
1540 0 : ;
1541 :
1542 : /* OMG Rule (41) */
1543 :
1544 : positive_int_const
1545 : : const_exp
1546 : {
1547 0 : IDLIntType posInt(idl_unsigned_long_long) ;
1548 0 : IDLConstExp *exp = $1 ;
1549 : idlSize size = 0 ;
1550 : IDLValue *value = NULL ;
1551 :
1552 0 : if (exp != NULL)
1553 : {
1554 0 : value = exp->evaluate(& posInt) ;
1555 : }
1556 :
1557 0 : if (value != NULL)
1558 : {
1559 0 : if (value->IsError() == false)
1560 : {
1561 : IDLIntValue *intVal = NULL ;
1562 : intVal = (IDLIntValue*) value ;
1563 0 : size = intVal->GetU64() ;
1564 : }
1565 : else
1566 : {
1567 0 : NON_DEV("error msg : positive_int_exp") ;
1568 : }
1569 : }
1570 : else
1571 : {
1572 0 : NON_DEV("error msg : positive_int_exp") ;
1573 : }
1574 :
1575 0 : if (value != NULL)
1576 : {
1577 0 : delete value ;
1578 : }
1579 :
1580 0 : if (exp != NULL)
1581 : {
1582 0 : delete exp ;
1583 : }
1584 :
1585 0 : $$ = size ;
1586 : }
1587 0 : ;
1588 :
1589 : /* OMG Rule (42) */
1590 :
1591 : type_dcl
1592 : : TOK_TYPEDEF type_declarator
1593 : {
1594 : /* No actions */
1595 557 : $$ = NULL ;
1596 : }
1597 557 : | struct_type
1598 : {
1599 : /* No actions */
1600 360 : $$ = NULL ;
1601 : }
1602 360 : | union_type
1603 : {
1604 0 : NON_DEV("type_dcl") ;
1605 : }
1606 0 : | enum_type
1607 : {
1608 : /* No actions */
1609 155 : $$ = NULL ;
1610 : }
1611 155 : | TOK_NATIVE simple_declarator
1612 : {
1613 4 : SimpleDeclarator *decl = $2 ;
1614 4 : String name = decl->GetName() ;
1615 4 : SymNative *native = new SymNative(name) ;
1616 4 : g_symTabPtr->addSymbol(native) ;
1617 :
1618 4 : delete decl ;
1619 4 : $$ = NULL ;
1620 : }
1621 4 : | constr_forward_decl
1622 : {
1623 0 : NON_DEV("type_dcl") ;
1624 : }
1625 0 : ;
1626 :
1627 : /* OMG Rule (43) */
1628 :
1629 : type_declarator
1630 : : type_spec declarators
1631 : {
1632 557 : IDLType *type = $1 ;
1633 557 : DeclaratorList *decls = $2 ;
1634 :
1635 : ASSERT(type != NULL) ;
1636 : ASSERT(decls != NULL) ;
1637 :
1638 557 : String name ;
1639 557 : Declarator *decl = NULL ;
1640 : Typedef *typedef_symbol = NULL ;
1641 557 : IDLType *typedef_type = NULL ;
1642 :
1643 557 : if (decls->size() == 1)
1644 : {
1645 557 : decl = decls->removeHead() ;
1646 :
1647 557 : name = ReverseTypeDeclaration(type, decl, typedef_type) ;
1648 :
1649 557 : typedef_symbol = new Typedef(name, typedef_type) ;
1650 557 : g_symTabPtr->addSymbol(typedef_symbol) ;
1651 : }
1652 : else
1653 : {
1654 : // DeclaratorListIt it(*decls) ;
1655 0 : NON_DEV("loop in type_declarator") ;
1656 : }
1657 :
1658 : decls->clear() ;
1659 1114 : delete decls ;
1660 : }
1661 557 : ;
1662 :
1663 : /* OMG Rule (44) */
1664 :
1665 : type_spec
1666 : : simple_type_spec
1667 : {
1668 2423 : $$ = $1 ;
1669 : }
1670 2423 : | constr_type_spec
1671 : {
1672 4 : $$ = $1 ;
1673 : }
1674 4 : ;
1675 :
1676 : /* OMG Rule (45) */
1677 :
1678 : simple_type_spec
1679 : : base_type_spec
1680 : {
1681 308 : $$ = $1 ;
1682 : }
1683 308 : | template_type_spec
1684 : {
1685 479 : $$ = $1 ;
1686 : }
1687 479 : | scoped_name
1688 : {
1689 2025 : Scope *scope = $1 ;
1690 2025 : Symbol *symbol = g_symTabPtr->findSymbol(*scope) ;
1691 :
1692 2025 : if (symbol == NULL)
1693 : {
1694 0 : String error = "Undefined symbol " ;
1695 0 : error += scope->GetFullName() ;
1696 0 : IDLCompileError(error) ;
1697 :
1698 0 : $$ = new IDLErrorType() ;
1699 : }
1700 : else
1701 : {
1702 2025 : $$ = Symbol2Type(symbol) ;
1703 : }
1704 : }
1705 : ;
1706 :
1707 : /* OMG Rule (46) */
1708 :
1709 : base_type_spec
1710 : : floating_pt_type
1711 : {
1712 0 : $$ = $1 ;
1713 : }
1714 0 : | integer_type
1715 : {
1716 741 : $$ = $1 ;
1717 : }
1718 741 : | char_type
1719 : {
1720 5 : $$ = $1 ;
1721 : }
1722 5 : | wide_char_type
1723 : {
1724 0 : $$ = $1 ;
1725 : }
1726 0 : | boolean_type
1727 : {
1728 621 : $$ = $1 ;
1729 : }
1730 621 : | octet_type
1731 : {
1732 5 : $$ = $1 ;
1733 : }
1734 5 : | any_type
1735 : {
1736 256 : $$ = $1 ;
1737 : }
1738 256 : | object_type
1739 : {
1740 82 : $$ = $1 ;
1741 : }
1742 82 : | value_base_type
1743 : {
1744 0 : $$ = $1 ;
1745 : }
1746 0 : ;
1747 :
1748 :
1749 : /* OMG Rule (47) */
1750 :
1751 : template_type_spec
1752 : : sequence_type
1753 : {
1754 389 : $$ = $1 ;
1755 : }
1756 389 : | string_type
1757 : {
1758 90 : $$ = $1 ;
1759 : }
1760 90 : | wide_string_type
1761 : {
1762 0 : $$ = $1 ;
1763 : }
1764 0 : | fixed_pt_type
1765 : {
1766 0 : $$ = $1 ;
1767 : }
1768 0 : ;
1769 :
1770 : /* OMG Rule (48) */
1771 :
1772 : constr_type_spec
1773 : : struct_type
1774 : {
1775 4 : $$ = $1 ;
1776 : }
1777 4 : | union_type
1778 : {
1779 0 : $$ = $1 ;
1780 : }
1781 0 : | enum_type
1782 : {
1783 0 : $$ = $1 ;
1784 : }
1785 0 : ;
1786 :
1787 : /* OMG Rule (49) */
1788 :
1789 : declarators
1790 : : declarator
1791 : {
1792 557 : $$ = new DeclaratorList($1) ;
1793 : }
1794 557 : | declarators TOK_COMMA declarator
1795 : {
1796 0 : $1->addTail($3) ;
1797 0 : $$ = $1 ;
1798 : }
1799 0 : ;
1800 :
1801 : /* OMG Rule (50) */
1802 :
1803 : declarator
1804 : : simple_declarator
1805 : {
1806 2426 : $$ = $1 ;
1807 : }
1808 2426 : | complex_declarator
1809 : {
1810 0 : $$ = $1 ;
1811 : }
1812 0 : ;
1813 :
1814 : /* OMG Rule (51) */
1815 :
1816 : simple_declarator
1817 : : TOK_IDENTIFIER
1818 : {
1819 6844 : String *str = $1 ;
1820 : ASSERT(str != NULL) ;
1821 :
1822 6844 : $$ = new SimpleDeclarator(*str) ;
1823 6844 : delete str ;
1824 : }
1825 : ;
1826 :
1827 : /* OMG Rule (52) */
1828 :
1829 : complex_declarator
1830 : : array_declarator
1831 : {
1832 0 : $$ = $1 ;
1833 : }
1834 0 : ;
1835 :
1836 : /* OMG Rule (53) */
1837 :
1838 : floating_pt_type
1839 : : TOK_FLOAT
1840 : {
1841 4 : $$ = new IDLFloatType(idl_float) ;
1842 : }
1843 4 : | TOK_DOUBLE
1844 : {
1845 4 : $$ = new IDLFloatType(idl_double) ;
1846 : }
1847 4 : | TOK_LONG TOK_DOUBLE
1848 : {
1849 4 : $$ = new IDLFloatType(idl_long_double) ;
1850 : }
1851 4 : ;
1852 :
1853 : /* OMG Rule (54) */
1854 :
1855 : integer_type
1856 : : signed_int
1857 : {
1858 452 : $$ = $1 ;
1859 : }
1860 452 : | unsigned_int
1861 : {
1862 738 : $$ = $1 ;
1863 : }
1864 738 : ;
1865 :
1866 : /* OMG Rule (55) */
1867 :
1868 : signed_int
1869 : : signed_short_int
1870 : {
1871 203 : $$ = $1 ;
1872 : }
1873 203 : | signed_long_int
1874 : {
1875 160 : $$ = $1 ;
1876 : }
1877 160 : | signed_longlong_int
1878 : {
1879 89 : $$ = $1 ;
1880 : }
1881 89 : ;
1882 :
1883 : /* OMG Rule (56) */
1884 :
1885 : signed_short_int
1886 : : TOK_SHORT
1887 : {
1888 203 : $$ = new IDLIntType(idl_signed_short) ;
1889 : }
1890 203 : ;
1891 :
1892 : /* OMG Rule (57) */
1893 :
1894 : signed_long_int
1895 : : TOK_LONG
1896 : {
1897 160 : $$ = new IDLIntType(idl_signed_long) ;
1898 : }
1899 160 : ;
1900 :
1901 : /* OMG Rule (58) */
1902 :
1903 : signed_longlong_int
1904 : : TOK_LONG TOK_LONG
1905 : {
1906 89 : $$ = new IDLIntType(idl_signed_long_long) ;
1907 : }
1908 89 : ;
1909 :
1910 : /* OMG Rule (59) */
1911 :
1912 : unsigned_int
1913 : : unsigned_short_int
1914 : {
1915 156 : $$ = $1 ;
1916 : }
1917 156 : | unsigned_long_int
1918 : {
1919 516 : $$ = $1 ;
1920 : }
1921 516 : | unsigned_longlong_int
1922 : {
1923 66 : $$ = $1 ;
1924 : }
1925 66 : ;
1926 :
1927 : /* OMG Rule (60) */
1928 :
1929 : unsigned_short_int
1930 : : TOK_UNSIGNED TOK_SHORT
1931 : {
1932 156 : $$ = new IDLIntType(idl_unsigned_short) ;
1933 : }
1934 156 : ;
1935 :
1936 : /* OMG Rule (61) */
1937 :
1938 : unsigned_long_int
1939 : : TOK_UNSIGNED TOK_LONG
1940 : {
1941 516 : $$ = new IDLIntType(idl_unsigned_long) ;
1942 : }
1943 516 : ;
1944 :
1945 : /* OMG Rule (62) */
1946 :
1947 : unsigned_longlong_int
1948 : : TOK_UNSIGNED TOK_LONG TOK_LONG
1949 : {
1950 66 : $$ = new IDLIntType(idl_unsigned_long_long) ;
1951 : }
1952 66 : ;
1953 :
1954 : /* OMG Rule (63) */
1955 :
1956 : char_type
1957 : : TOK_CHAR
1958 : {
1959 23 : $$ = new IDLCharType() ;
1960 : }
1961 23 : ;
1962 :
1963 : /* OMG Rule (64) */
1964 :
1965 : wide_char_type
1966 : : TOK_WCHAR
1967 : {
1968 16 : $$ = new IDLWCharType() ;
1969 : }
1970 16 : ;
1971 :
1972 : /* OMG Rule (65) */
1973 :
1974 : boolean_type
1975 : : TOK_BOOLEAN
1976 : {
1977 621 : $$ = new IDLBoolType() ;
1978 : }
1979 621 : ;
1980 :
1981 : /* OMG Rule (66) */
1982 :
1983 : octet_type
1984 : : TOK_OCTET
1985 : {
1986 9 : $$ = new IDLOctetType() ;
1987 : }
1988 9 : ;
1989 :
1990 : /* OMG Rule (67) */
1991 :
1992 : any_type
1993 : : TOK_ANY
1994 : {
1995 256 : $$ = new IDLAnyType() ;
1996 : }
1997 256 : ;
1998 :
1999 : /* OMG Rule (68) */
2000 :
2001 : object_type
2002 : : TOK_OBJECT
2003 : {
2004 82 : $$ = new IDLObjectType() ;
2005 : }
2006 82 : ;
2007 :
2008 : /* OMG Rule (69) */
2009 :
2010 : struct_type
2011 : : TOK_STRUCT TOK_IDENTIFIER
2012 : TOK_LEFT_CURLY_BRAKET member_list TOK_RIGHT_CURLY_BRAKET
2013 : {
2014 364 : String *structName = $2 ;
2015 364 : MemberList *members = $4 ;
2016 :
2017 : ASSERT(structName != NULL) ;
2018 : ASSERT(members != NULL) ;
2019 :
2020 364 : Struct *structure = new Struct(*structName) ;
2021 :
2022 : MemberListIt it(*members) ;
2023 : Member *member ;
2024 :
2025 364 : g_symTabPtr->openContext(*structName) ;
2026 :
2027 2119 : while (it.GetNext())
2028 : {
2029 : member = it.GetItem() ;
2030 1755 : structure->addMember(member) ;
2031 1755 : g_symTabPtr->addSymbol(member) ;
2032 : }
2033 :
2034 364 : g_symTabPtr->closeContext() ;
2035 :
2036 364 : g_symTabPtr->addSymbol(structure) ;
2037 :
2038 364 : delete structName ;
2039 : members->clear() ; // structure has ownership
2040 728 : delete members ;
2041 :
2042 364 : $$ = new IDLStructType(structure) ;
2043 : }
2044 : ;
2045 :
2046 : /* OMG Rule (70) */
2047 :
2048 : member_list
2049 : : member
2050 : {
2051 465 : $$ = new MemberList($1) ;
2052 : }
2053 465 : | member_list member
2054 : {
2055 1404 : $1->addTail($2) ;
2056 1404 : $$ = $1 ;
2057 : }
2058 1404 : ;
2059 :
2060 : /* OMG Rule (71) */
2061 :
2062 : member
2063 : : type_spec declarator TOK_SEMICOLON
2064 : {
2065 1869 : IDLType *type = NULL ;
2066 1869 : String name ;
2067 :
2068 1869 : name = ReverseTypeDeclaration($1, $2, type) ;
2069 1869 : $$ = new Member(name, type) ;
2070 : }
2071 1869 : ;
2072 :
2073 : /* OMG Rule (72) */
2074 :
2075 : union_type
2076 : : TOK_UNION TOK_IDENTIFIER TOK_SWITCH
2077 : TOK_LEFT_PARENTHESIS switch_type_spec TOK_RIGHT_PARENTHESIS
2078 : TOK_LEFT_CURLY_BRAKET switch_body TOK_RIGHT_CURLY_BRAKET
2079 : {
2080 0 : NON_DEV("union") ;
2081 : }
2082 0 : ;
2083 :
2084 : /* OMG Rule (73) */
2085 :
2086 : switch_type_spec
2087 : : integer_type
2088 : {
2089 0 : $$ = $1 ;
2090 : }
2091 0 : | char_type
2092 : {
2093 0 : $$ = $1 ;
2094 : }
2095 0 : | boolean_type
2096 : {
2097 0 : $$ = $1 ;
2098 : }
2099 0 : | enum_type
2100 : {
2101 0 : $$ = $1 ;
2102 : }
2103 0 : | scoped_name
2104 : {
2105 0 : NON_DEV("switch_type_spec") ;
2106 : }
2107 0 : ;
2108 :
2109 : /* OMG Rule (74) */
2110 :
2111 : switch_body
2112 : : case
2113 : | switch_body case
2114 : ;
2115 :
2116 : /* OMG Rule (75-a) */
2117 :
2118 : case
2119 : : case_label_lst element_spec TOK_SEMICOLON
2120 : ;
2121 :
2122 : /* OMG Rule (75-b) */
2123 :
2124 : case_label_lst
2125 : : case_label
2126 : | case_label_lst case_label
2127 : ;
2128 :
2129 : /* OMG Rule (76) */
2130 :
2131 : case_label
2132 : : TOK_CASE const_exp TOK_COLON
2133 : {
2134 0 : NON_DEV("case_label") ;
2135 : }
2136 0 : | TOK_DEFAULT TOK_COLON
2137 : {
2138 0 : NON_DEV("case_label") ;
2139 : }
2140 0 : ;
2141 :
2142 : /* OMG Rule (77) */
2143 :
2144 : element_spec
2145 : : type_spec declarator
2146 : {
2147 0 : NON_DEV("element_spec") ;
2148 : }
2149 0 : ;
2150 :
2151 : /* OMG Rule (78-a) */
2152 :
2153 : enum_type
2154 : : TOK_ENUM TOK_IDENTIFIER
2155 : TOK_LEFT_CURLY_BRAKET enumerator_lst TOK_RIGHT_CURLY_BRAKET
2156 : {
2157 155 : String *enumName = $2 ;
2158 155 : StringList *enumItems = $4 ;
2159 :
2160 : ASSERT(enumName != NULL) ;
2161 : ASSERT(enumItems != NULL) ;
2162 :
2163 155 : Enum *enumSymbol = new Enum(*enumName) ;
2164 :
2165 : StringListIt it(*enumItems) ;
2166 : String *itemName = NULL ;
2167 : EnumItem *item = NULL ;
2168 :
2169 1816 : while (it.GetNext())
2170 : {
2171 : itemName = it.GetItem() ;
2172 :
2173 1506 : item = new EnumItem(*itemName) ;
2174 1506 : enumSymbol->addItem(item) ;
2175 1506 : g_symTabPtr->addSymbol(item) ;
2176 : } ;
2177 :
2178 155 : g_symTabPtr->addSymbol(enumSymbol) ;
2179 :
2180 : enumItems->clearAndDestroy() ;
2181 310 : delete enumItems ;
2182 155 : delete enumName ;
2183 : }
2184 : ;
2185 :
2186 : /* OMG Rule (78-b) */
2187 :
2188 : enumerator_lst
2189 : : enumerator
2190 : {
2191 155 : $$ = new StringList($1) ;
2192 : }
2193 155 : | enumerator_lst TOK_COMMA enumerator
2194 : {
2195 1351 : $1->addTail($3) ;
2196 1351 : $$ = $1 ;
2197 : }
2198 1351 : ;
2199 :
2200 : /* OMG Rule (79) */
2201 :
2202 : enumerator
2203 : : TOK_IDENTIFIER
2204 : {
2205 1506 : $$ = $1 ;
2206 : }
2207 1506 : ;
2208 :
2209 : /* OMG Rule (80) */
2210 :
2211 : sequence_type
2212 : : TOK_SEQUENCE
2213 : TOK_LESS_THAN simple_type_spec
2214 : TOK_COMMA positive_int_const TOK_GREATER_THAN
2215 : {
2216 0 : idlSize size = $5 ;
2217 :
2218 0 : $$ = new IDLSequenceType($3, size) ;
2219 : }
2220 0 : | TOK_SEQUENCE
2221 : TOK_LESS_THAN simple_type_spec TOK_GREATER_THAN
2222 : {
2223 389 : $$ = new IDLSequenceType($3) ;
2224 : }
2225 389 : ;
2226 :
2227 : /* OMG Rule (81) */
2228 :
2229 : string_type
2230 : : TOK_STRING TOK_LESS_THAN positive_int_const TOK_GREATER_THAN
2231 : {
2232 0 : idlSize size = $3 ;
2233 :
2234 0 : $$ = new IDLStringType(size) ;
2235 : }
2236 0 : | TOK_STRING
2237 : {
2238 141 : $$ = new IDLStringType() ;
2239 : }
2240 141 : ;
2241 :
2242 : /* OMG Rule (82) */
2243 :
2244 : wide_string_type
2245 : : TOK_WSTRING TOK_LESS_THAN positive_int_const TOK_GREATER_THAN
2246 : {
2247 0 : idlSize size = $3 ;
2248 :
2249 0 : $$ = new IDLWStringType(size) ;
2250 : }
2251 0 : | TOK_WSTRING
2252 : {
2253 1 : $$ = new IDLWStringType() ;
2254 : }
2255 1 : ;
2256 :
2257 : /* OMG Rule (83-a) */
2258 :
2259 : array_declarator
2260 : : TOK_IDENTIFIER fixed_array_size_lst
2261 : {
2262 0 : String *str = $1 ;
2263 : Declarator *result = NULL ;
2264 : ASSERT(str != NULL) ;
2265 :
2266 0 : result = new SimpleDeclarator(*str) ;
2267 0 : delete str ;
2268 :
2269 0 : NON_DEV("array : fixed_array_size_lst") ;
2270 :
2271 0 : $$ = result ;
2272 : }
2273 0 : ;
2274 :
2275 : /* OMG Rule (83-b) */
2276 :
2277 : fixed_array_size_lst
2278 : : fixed_array_size
2279 : {
2280 0 : NON_DEV("fixed_array_size_lst") ;
2281 : }
2282 0 : | fixed_array_size_lst fixed_array_size
2283 : {
2284 0 : NON_DEV("fixed_array_size_lst") ;
2285 : }
2286 0 : ;
2287 :
2288 : /* OMG Rule (84) */
2289 :
2290 : fixed_array_size
2291 : : TOK_LEFT_SQUARE_BRAKET positive_int_const TOK_RIGHT_SQUARE_BRAKET
2292 : {
2293 0 : NON_DEV("fixed_array_size") ;
2294 : }
2295 0 : ;
2296 :
2297 : /* OMG Rule (85) */
2298 :
2299 : attr_dcl
2300 : : readonly_attr_spec
2301 : /* No actions */
2302 : | attr_spec
2303 : /* No actions */
2304 : ;
2305 :
2306 : /* OMG Rule (86-a) */
2307 :
2308 : except_dcl
2309 : : TOK_EXCEPTION TOK_IDENTIFIER
2310 : TOK_LEFT_CURLY_BRAKET member_lst_opt TOK_RIGHT_CURLY_BRAKET
2311 : {
2312 285 : String *exceptName = $2 ;
2313 285 : MemberList *members = $4 ;
2314 :
2315 : ASSERT(exceptName != NULL) ;
2316 : ASSERT(members != NULL) ;
2317 :
2318 285 : Exception *ex = new Exception(*exceptName) ;
2319 :
2320 : MemberListIt it(*members) ;
2321 : Member *member ;
2322 :
2323 285 : g_symTabPtr->openContext(*exceptName) ;
2324 :
2325 399 : while (it.GetNext())
2326 : {
2327 : member = it.GetItem() ;
2328 114 : ex->addMember(member) ;
2329 114 : g_symTabPtr->addSymbol(member) ;
2330 : }
2331 :
2332 285 : g_symTabPtr->closeContext() ;
2333 :
2334 285 : g_symTabPtr->addSymbol(ex) ;
2335 :
2336 285 : delete exceptName ;
2337 : members->clear() ; // exception has ownership
2338 570 : delete members ;
2339 : }
2340 : ;
2341 :
2342 : /* OMG Rule (86-b) */
2343 :
2344 : member_lst_opt
2345 : : /* empty */
2346 : {
2347 184 : $$ = new MemberList() ;
2348 : }
2349 184 : | member_list
2350 : {
2351 101 : $$ = $1 ;
2352 : }
2353 101 : ;
2354 :
2355 : /* OMG Rule (87-a) */
2356 :
2357 : op_dcl
2358 : : op_attribute_opt op_type_spec TOK_IDENTIFIER
2359 : parameter_dcls raises_expr_opt context_expr_opt
2360 : {
2361 2111 : OperationAttribute opAttr = $1 ;
2362 2111 : IDLType *opType = $2 ;
2363 2111 : String *opName = $3 ;
2364 2111 : ParameterList *params = $4 ;
2365 2111 : ScopeList *exceptions = $5 ;
2366 2111 : StringList *contexts = $6 ;
2367 :
2368 : ASSERT(opType != NULL) ;
2369 : ASSERT(opName != NULL) ;
2370 : ASSERT(params != NULL) ;
2371 :
2372 2111 : Operation *op = new Operation(opAttr, opType, *opName) ;
2373 :
2374 2111 : g_symTabPtr->addSymbol(op) ;
2375 2111 : g_symTabPtr->openContext("") ;
2376 :
2377 : ParameterListIt it(*params) ;
2378 : Parameter *param = NULL ;
2379 :
2380 7695 : while (it.GetNext())
2381 : {
2382 : param = it.GetItem() ;
2383 :
2384 3473 : g_symTabPtr->addSymbol(param) ;
2385 3473 : op->addParameter(param) ;
2386 : }
2387 :
2388 2111 : g_symTabPtr->closeContext() ;
2389 :
2390 2111 : if (exceptions != NULL)
2391 : {
2392 : ScopeListIt it(*exceptions) ;
2393 : Scope *scope = NULL ;
2394 : Symbol *sym = NULL ;
2395 :
2396 1879 : while (it.GetNext())
2397 : {
2398 : scope = it.GetItem() ;
2399 1176 : sym = g_symTabPtr->findSymbol(*scope) ;
2400 :
2401 1176 : if (sym == NULL)
2402 : {
2403 0 : String error = "Unknown exception." ;
2404 0 : IDLCompileError(error) ;
2405 0 : scope->print(errLog) ;
2406 0 : errLog << std::endl ;
2407 : }
2408 : else
2409 : {
2410 1176 : if (sym->GetClass() == exceptionSymbol)
2411 : {
2412 : Exception *except = (Exception*) sym ;
2413 1176 : op->addException(except) ;
2414 : }
2415 : else
2416 : {
2417 0 : String error = "Not an exception." ;
2418 0 : IDLCompileError(error) ;
2419 0 : sym->print(errLog) ;
2420 0 : errLog << std::endl ;
2421 : }
2422 : }
2423 : }
2424 : }
2425 :
2426 2111 : if (contexts != NULL)
2427 : {
2428 0 : NON_DEV("op_dcl with context") ;
2429 : }
2430 :
2431 : params->clear() ;
2432 4222 : delete params ;
2433 2111 : delete opName ;
2434 : }
2435 : ;
2436 :
2437 : /* OMG Rule (87-b) */
2438 :
2439 : op_attribute_opt
2440 : : /* empty */
2441 : {
2442 2111 : $$ = OPERATION_TWOWAYS ;
2443 : }
2444 2111 : | op_attribute
2445 : {
2446 0 : $$ = $1 ;
2447 : }
2448 0 : ;
2449 :
2450 : /* OMG Rule (87-c) */
2451 :
2452 : raises_expr_opt
2453 : : /* empty */
2454 : {
2455 1408 : $$ = NULL ;
2456 : }
2457 1408 : | raises_expr
2458 : {
2459 703 : $$ = $1 ;
2460 : }
2461 703 : ;
2462 :
2463 : /* OMG Rule (87-d) */
2464 :
2465 : context_expr_opt
2466 : : /* empty */
2467 : {
2468 2111 : $$ = NULL ;
2469 : }
2470 2111 : | context_expr
2471 : {
2472 0 : $$ = $1 ;
2473 : }
2474 0 : ;
2475 :
2476 : /* OMG Rule (88) */
2477 :
2478 : op_attribute
2479 : : TOK_ONEWAY
2480 : {
2481 0 : $$ = OPERATION_ONEWAY ;
2482 : }
2483 0 : ;
2484 :
2485 : /* OMG Rule (89) */
2486 :
2487 : op_type_spec
2488 : : param_type_spec
2489 : {
2490 1647 : $$ = $1 ;
2491 : }
2492 1647 : | TOK_VOID
2493 : {
2494 464 : $$ = new IDLVoidType() ;
2495 : }
2496 464 : ;
2497 :
2498 : /* OMG Rule (90-a) */
2499 :
2500 : parameter_dcls
2501 : : TOK_LEFT_PARENTHESIS param_dcl_lst TOK_RIGHT_PARENTHESIS
2502 : {
2503 1515 : $$ = $2 ;
2504 : }
2505 1515 : | TOK_LEFT_PARENTHESIS TOK_RIGHT_PARENTHESIS
2506 : {
2507 596 : $$ = new ParameterList() ;
2508 : }
2509 596 : ;
2510 :
2511 : /* OMG Rule (90-b) */
2512 :
2513 : param_dcl_lst
2514 : : param_dcl
2515 : {
2516 1515 : $$ = new ParameterList($1) ;
2517 : }
2518 1515 : | param_dcl_lst TOK_COMMA param_dcl
2519 : {
2520 1958 : $1->addTail($3) ;
2521 1958 : $$ = $1 ;
2522 : }
2523 1958 : ;
2524 :
2525 : /* OMG Rule (91) */
2526 :
2527 : param_dcl
2528 : : param_attribute param_type_spec simple_declarator
2529 : {
2530 3473 : ParameterAttribute attrib = $1 ;
2531 3473 : Declarator *decl = $3 ;
2532 3473 : IDLType *type = NULL ;
2533 3473 : String name ;
2534 :
2535 3473 : name = ReverseTypeDeclaration($2, decl, type) ;
2536 3473 : $$ = new Parameter(attrib, name, type) ;
2537 : }
2538 3473 : ;
2539 :
2540 : /* OMG Rule (92) */
2541 :
2542 : param_attribute
2543 : : TOK_IN
2544 : {
2545 3293 : $$ = PARAMETER_IN ;
2546 : }
2547 3293 : | TOK_OUT
2548 : {
2549 180 : $$ = PARAMETER_OUT ;
2550 : }
2551 180 : | TOK_INOUT
2552 : {
2553 0 : $$ = PARAMETER_INOUT ;
2554 : }
2555 0 : ;
2556 :
2557 : /* OMG Rule (93-a) */
2558 :
2559 : raises_expr
2560 : : TOK_RAISES TOK_LEFT_PARENTHESIS scoped_name_lst TOK_RIGHT_PARENTHESIS
2561 : {
2562 703 : $$ = $3 ;
2563 : }
2564 703 : ;
2565 :
2566 : /* OMG Rule (93-b) */
2567 :
2568 : scoped_name_lst
2569 : : scoped_name
2570 : {
2571 703 : $$ = new ScopeList($1) ;
2572 : }
2573 703 : | scoped_name_lst TOK_COMMA scoped_name
2574 : {
2575 473 : $1->addTail($3) ;
2576 473 : $$ = $1 ;
2577 : }
2578 473 : ;
2579 :
2580 : /* OMG Rule (94-a) */
2581 :
2582 : context_expr
2583 : : TOK_CONTEXT TOK_LEFT_PARENTHESIS string_literal_lst TOK_RIGHT_PARENTHESIS
2584 : {
2585 0 : $$ = $3 ;
2586 : }
2587 0 : ;
2588 :
2589 : /* OMG Rule (94-b) */
2590 :
2591 : string_literal_lst
2592 : : string_literal
2593 : {
2594 0 : $$ = new StringList($1) ;
2595 : }
2596 0 : | string_literal_lst TOK_COMMA string_literal
2597 : {
2598 0 : $1->addTail($3) ;
2599 0 : $$ = $1 ;
2600 : }
2601 0 : ;
2602 :
2603 : /* OMG Rule (95) */
2604 :
2605 : param_type_spec
2606 : : base_type_spec
2607 : {
2608 1402 : $$ = $1 ;
2609 : }
2610 1402 : | string_type
2611 : {
2612 50 : $$ = $1 ;
2613 : }
2614 50 : | wide_string_type
2615 : {
2616 0 : $$ = $1 ;
2617 : }
2618 0 : | scoped_name
2619 : {
2620 4609 : Scope *scope = $1 ;
2621 : ASSERT(scope != NULL) ;
2622 :
2623 4609 : Symbol *symbol = g_symTabPtr->findSymbol(*scope) ;
2624 :
2625 4609 : if (symbol == NULL)
2626 : {
2627 3 : String error = "Undefined symbol " ;
2628 3 : error += scope->GetFullName() ;
2629 3 : IDLCompileError(error) ;
2630 :
2631 3 : $$ = new IDLErrorType() ;
2632 : }
2633 : else
2634 : {
2635 4606 : $$ = Symbol2Type(symbol) ;
2636 : }
2637 :
2638 4609 : delete scope ;
2639 : }
2640 : ;
2641 :
2642 : /* OMG Rule (96) */
2643 :
2644 : fixed_pt_type
2645 : : TOK_FIXED TOK_LESS_THAN positive_int_const
2646 : TOK_COMMA positive_int_const TOK_GREATER_THAN
2647 : {
2648 : // idlSize size1 = $3 ;
2649 : // idlSize size2 = $5 ;
2650 0 : NON_DEV("fixed <N,N>") ;
2651 0 : $$ = new IDLErrorType() ;
2652 : }
2653 0 : ;
2654 :
2655 : /* OMG Rule (97) */
2656 :
2657 : fixed_pt_const_type
2658 : : TOK_FIXED
2659 : {
2660 0 : NON_DEV("fixed") ;
2661 0 : $$ = new IDLErrorType() ;
2662 : }
2663 0 : ;
2664 :
2665 : /* OMG Rule (98) */
2666 :
2667 : value_base_type
2668 : : TOK_VALUEBASE
2669 : {
2670 0 : NON_DEV("value_base_type") ;
2671 0 : $$ = new IDLErrorType() ;
2672 : }
2673 0 : ;
2674 :
2675 : /* OMG Rule (99) */
2676 :
2677 : constr_forward_decl
2678 : : TOK_STRUCT TOK_IDENTIFIER
2679 : | TOK_UNION TOK_IDENTIFIER
2680 : ;
2681 :
2682 : /* OMG Rule (100) */
2683 :
2684 : import
2685 : : TOK_IMPORT imported_scope TOK_SEMICOLON
2686 : {
2687 0 : NON_DEV("import") ;
2688 : }
2689 0 : ;
2690 :
2691 : /* OMG Rule (101) */
2692 :
2693 : imported_scope
2694 : : scoped_name
2695 : {
2696 0 : NON_DEV("imported_scope") ;
2697 : }
2698 0 : | string_literal
2699 : {
2700 0 : NON_DEV("imported_scope") ;
2701 : }
2702 0 : ;
2703 :
2704 : /* OMG Rule (102) */
2705 :
2706 : type_id_dcl
2707 : : TOK_TYPEID scoped_name string_literal
2708 : {
2709 0 : NON_DEV("type_id_dcl") ;
2710 : }
2711 0 : ;
2712 :
2713 : /* OMG Rule (103) */
2714 :
2715 : type_prefix_dcl
2716 : : TOK_TYPEPREFIX scoped_name string_literal
2717 : {
2718 0 : NON_DEV("type_prefix_dcl") ;
2719 : }
2720 0 : ;
2721 :
2722 : /* OMG Rule (104) */
2723 :
2724 : readonly_attr_spec
2725 : : TOK_READONLY TOK_ATTRIBUTE param_type_spec readonly_attr_declarator
2726 : {
2727 345 : SimpleDeclaratorList *attrList = $4 ;
2728 345 : IDLType *type = $3 ;
2729 :
2730 345 : Declarator *decl = NULL ;
2731 345 : String attrName ;
2732 345 : IDLType *attrType = NULL ;
2733 : Attribute *attribute = NULL ;
2734 :
2735 345 : if (attrList->size() == 1)
2736 : {
2737 345 : decl = attrList->removeHead() ;
2738 345 : attrName = ReverseTypeDeclaration(type, decl, attrType) ;
2739 345 : attribute = new Attribute(ATTRIBUTE_READONLY, attrName, attrType) ;
2740 :
2741 345 : g_symTabPtr->addSymbol(attribute) ;
2742 : }
2743 : else
2744 : {
2745 0 : NON_DEV("deep copy type, and loop") ;
2746 : }
2747 :
2748 0 : attrList->clearAndDestroy() ;
2749 : }
2750 345 : ;
2751 :
2752 : /* OMG Rule (105-a) */
2753 :
2754 : readonly_attr_declarator
2755 : : simple_declarator raises_expr
2756 : {
2757 0 : NON_DEV("readonly_attr_declarator : $2") ;
2758 0 : $$ = new SimpleDeclaratorList($1) ;
2759 : }
2760 0 : | simple_declarator_lst
2761 : {
2762 345 : NON_DEV("readonly_attr_declarator") ;
2763 : }
2764 345 : ;
2765 :
2766 : /* OMG Rule (105-b) */
2767 :
2768 : simple_declarator_lst
2769 : : simple_declarator
2770 : {
2771 941 : $$ = new SimpleDeclaratorList($1) ;
2772 : }
2773 941 : | simple_declarator_lst TOK_COMMA simple_declarator
2774 : {
2775 0 : $1->addTail($3) ;
2776 0 : $$ = $1 ;
2777 : }
2778 0 : ;
2779 :
2780 : /* OMG Rule (106) */
2781 :
2782 : attr_spec
2783 : : TOK_ATTRIBUTE param_type_spec attr_declarator
2784 : {
2785 596 : SimpleDeclaratorList *attrList = $3 ;
2786 596 : IDLType *type = $2 ;
2787 :
2788 596 : Declarator *decl = NULL ;
2789 596 : String attrName ;
2790 596 : IDLType *attrType = NULL ;
2791 : Attribute *attribute = NULL ;
2792 :
2793 596 : if (attrList->size() == 1)
2794 : {
2795 596 : decl = attrList->removeHead() ;
2796 596 : attrName = ReverseTypeDeclaration(type, decl, attrType) ;
2797 596 : attribute = new Attribute(ATTRIBUTE_READWRITE, attrName, attrType) ;
2798 :
2799 596 : g_symTabPtr->addSymbol(attribute) ;
2800 : }
2801 : else
2802 : {
2803 0 : NON_DEV("deep copy type, and loop") ;
2804 : }
2805 :
2806 0 : attrList->clearAndDestroy() ;
2807 : }
2808 596 : ;
2809 :
2810 : /* OMG Rule (107) */
2811 :
2812 : attr_declarator
2813 : : simple_declarator attr_raises_expr
2814 : {
2815 0 : NON_DEV("attr_declarator : $2") ;
2816 0 : $$ = new SimpleDeclaratorList($1) ;
2817 : }
2818 0 : | simple_declarator_lst
2819 : {
2820 596 : $$ = $1 ;
2821 : }
2822 596 : ;
2823 :
2824 : /* OMG Rule (108) */
2825 :
2826 : attr_raises_expr
2827 : : get_excep_expr
2828 : {
2829 0 : NON_DEV("attr_raises_expr") ;
2830 : }
2831 0 : | get_excep_expr set_excep_expr
2832 : {
2833 0 : NON_DEV("attr_raises_expr") ;
2834 : }
2835 0 : | set_excep_expr
2836 : {
2837 0 : NON_DEV("attr_raises_expr") ;
2838 : }
2839 0 : ;
2840 :
2841 : /* OMG Rule (109) */
2842 :
2843 : get_excep_expr
2844 : : TOK_GETRAISES exception_list
2845 : {
2846 0 : NON_DEV("get_excep_expr") ;
2847 : }
2848 0 : ;
2849 :
2850 : /* OMG Rule (110) */
2851 :
2852 : set_excep_expr
2853 : : TOK_SETRAISES exception_list
2854 : {
2855 0 : NON_DEV("set_excep_expr") ;
2856 : }
2857 0 : ;
2858 :
2859 : /* OMG Rule (111) */
2860 :
2861 : exception_list
2862 : : TOK_LEFT_PARENTHESIS scoped_name_lst TOK_RIGHT_PARENTHESIS
2863 : {
2864 0 : NON_DEV("exception_list") ;
2865 : }
2866 0 : ;
2867 :
2868 : /* OMG Rule (112) */
2869 :
2870 : component
2871 : : component_dcl
2872 : {
2873 0 : NON_DEV("component") ;
2874 : }
2875 0 : | component_forward_dcl
2876 : {
2877 0 : NON_DEV("component") ;
2878 : }
2879 0 : ;
2880 :
2881 : /* OMG Rule (113) */
2882 :
2883 : component_forward_dcl
2884 : : TOK_COMPONENT TOK_IDENTIFIER
2885 : {
2886 0 : NON_DEV("component_forward_dcl") ;
2887 : }
2888 0 : ;
2889 :
2890 : /* OMG Rule (114) */
2891 :
2892 : component_dcl
2893 : : component_header
2894 : TOK_LEFT_CURLY_BRAKET component_body TOK_RIGHT_CURLY_BRAKET
2895 : {
2896 0 : NON_DEV("component_dcl") ;
2897 : }
2898 0 : ;
2899 :
2900 : /* OMG Rule (115-a) */
2901 :
2902 : component_header
2903 : : TOK_COMPONENT TOK_IDENTIFIER
2904 : component_inheritance_spec_opt
2905 : supported_interface_spec_opt
2906 : {
2907 0 : NON_DEV("component_header") ;
2908 : }
2909 0 : ;
2910 :
2911 : /* OMG Rule (115-b) */
2912 :
2913 : component_inheritance_spec_opt
2914 : : /* empty */
2915 : {
2916 0 : NON_DEV("component_inheritance_spec_opt") ;
2917 : }
2918 0 : | component_inheritance_spec
2919 : {
2920 0 : NON_DEV("component_inheritance_spec_opt") ;
2921 : }
2922 0 : ;
2923 :
2924 : /* OMG Rule (115-c) */
2925 :
2926 : supported_interface_spec_opt
2927 : : /* empty */
2928 : {
2929 0 : NON_DEV("supported_interface_spec_opt") ;
2930 : }
2931 0 : | supported_interface_spec
2932 : {
2933 0 : NON_DEV("supported_interface_spec_opt") ;
2934 : }
2935 0 : ;
2936 :
2937 : /* OMG Rule (116) */
2938 :
2939 : supported_interface_spec
2940 : : TOK_SUPPORTS scoped_name_lst
2941 : {
2942 0 : NON_DEV("supported_interface_spec") ;
2943 : }
2944 0 : ;
2945 :
2946 : /* OMG Rule (117) */
2947 :
2948 : component_inheritance_spec
2949 : : TOK_COLON scoped_name
2950 : {
2951 0 : NON_DEV("component_inheritance_spec") ;
2952 : }
2953 0 : ;
2954 :
2955 : /* OMG Rule (118-a) */
2956 :
2957 : component_body
2958 : : /* empty */
2959 : {
2960 0 : NON_DEV("component_body") ;
2961 : }
2962 0 : | component_export_lst
2963 : {
2964 0 : NON_DEV("component_body") ;
2965 : }
2966 0 : ;
2967 :
2968 : /* OMG Rule (118-b) */
2969 :
2970 : component_export_lst
2971 : : component_export
2972 : {
2973 0 : NON_DEV("component_export_lst") ;
2974 : }
2975 0 : | component_export_lst component_export
2976 : {
2977 0 : NON_DEV("component_export_lst") ;
2978 : }
2979 0 : ;
2980 :
2981 : /* OMG Rule (119) */
2982 :
2983 : component_export
2984 : : provides_dcl TOK_SEMICOLON
2985 : {
2986 0 : NON_DEV("component_export") ;
2987 : }
2988 0 : | uses_dcl TOK_SEMICOLON
2989 : {
2990 0 : NON_DEV("component_export") ;
2991 : }
2992 0 : | emits_dcl TOK_SEMICOLON
2993 : {
2994 0 : NON_DEV("component_export") ;
2995 : }
2996 0 : | publishes_dcl TOK_SEMICOLON
2997 : {
2998 0 : NON_DEV("component_export") ;
2999 : }
3000 0 : | consumes_dcl TOK_SEMICOLON
3001 : {
3002 0 : NON_DEV("component_export") ;
3003 : }
3004 0 : | attr_dcl TOK_SEMICOLON
3005 : {
3006 0 : NON_DEV("component_export") ;
3007 : }
3008 0 : ;
3009 :
3010 : /* OMG Rule (120) */
3011 :
3012 : provides_dcl
3013 : : TOK_PROVIDES interface_type TOK_IDENTIFIER
3014 : {
3015 0 : NON_DEV("provides_dcl") ;
3016 : }
3017 0 : ;
3018 :
3019 : /* OMG Rule (121) */
3020 :
3021 : interface_type
3022 : : scoped_name
3023 : {
3024 0 : NON_DEV("interface_type") ;
3025 : }
3026 0 : | TOK_OBJECT
3027 : {
3028 0 : NON_DEV("interface_type") ;
3029 : }
3030 0 : ;
3031 :
3032 : /* OMG Rule (122) */
3033 :
3034 : uses_dcl
3035 : : TOK_USES TOK_MULTIPLE interface_type TOK_IDENTIFIER
3036 : {
3037 0 : NON_DEV("uses_dcl") ;
3038 : }
3039 0 : | TOK_USES interface_type TOK_IDENTIFIER
3040 : {
3041 0 : NON_DEV("uses_dcl") ;
3042 : }
3043 0 : ;
3044 :
3045 : /* OMG Rule (123) */
3046 :
3047 : emits_dcl
3048 : : TOK_EMITS scoped_name TOK_IDENTIFIER
3049 : {
3050 0 : NON_DEV("emits_dcl") ;
3051 : }
3052 0 : ;
3053 :
3054 : /* OMG Rule (124) */
3055 :
3056 : publishes_dcl
3057 : : TOK_PUBLISHES scoped_name TOK_IDENTIFIER
3058 : {
3059 0 : NON_DEV("publishes_dcl") ;
3060 : }
3061 0 : ;
3062 :
3063 : /* OMG Rule (125) */
3064 :
3065 : consumes_dcl
3066 : : TOK_CONSUMES scoped_name TOK_IDENTIFIER
3067 : {
3068 0 : NON_DEV("consumes_dcl") ;
3069 : }
3070 0 : ;
3071 :
3072 : /* OMG Rule (126) */
3073 :
3074 : home_dcl
3075 : : home_header home_body
3076 : {
3077 0 : NON_DEV("home_dcl") ;
3078 : }
3079 0 : ;
3080 :
3081 : /* OMG Rule (127-a) */
3082 :
3083 : home_header
3084 : : TOK_HOME TOK_IDENTIFIER
3085 : home_inheritance_spec_opt
3086 : supported_interface_spec_opt
3087 : TOK_MANAGES scoped_name
3088 : primary_key_spec_opt
3089 : {
3090 0 : NON_DEV("home_header") ;
3091 : }
3092 0 : ;
3093 :
3094 : /* OMG Rule (127-b) */
3095 :
3096 : home_inheritance_spec_opt
3097 : : /* empty */
3098 : {
3099 0 : NON_DEV("home_inheritance_spec_opt") ;
3100 : }
3101 0 : | home_inheritance_spec
3102 : {
3103 0 : NON_DEV("home_inheritance_spec_opt") ;
3104 : }
3105 0 : ;
3106 :
3107 : /* OMG Rule (127-c) */
3108 :
3109 : primary_key_spec_opt
3110 : : /* empty */
3111 : {
3112 0 : NON_DEV("primary_key_spec_opt") ;
3113 : }
3114 0 : | primary_key_spec
3115 : {
3116 0 : NON_DEV("primary_key_spec_opt") ;
3117 : }
3118 0 : ;
3119 :
3120 : /* OMG Rule (128) */
3121 :
3122 : home_inheritance_spec
3123 : : TOK_COLON scoped_name
3124 : {
3125 0 : NON_DEV("home_inheritance_spec") ;
3126 : }
3127 0 : ;
3128 :
3129 : /* OMG Rule (129) */
3130 :
3131 : primary_key_spec
3132 : : TOK_PRIMARYKEY scoped_name
3133 : {
3134 0 : NON_DEV("primary_key_spec") ;
3135 : }
3136 0 : ;
3137 :
3138 : /* OMG Rule (130-a) */
3139 :
3140 : home_body
3141 : : TOK_LEFT_CURLY_BRAKET home_export_lst_opt TOK_RIGHT_CURLY_BRAKET
3142 : {
3143 0 : NON_DEV("home_body") ;
3144 : }
3145 0 : ;
3146 :
3147 : /* OMG Rule (130-b) */
3148 :
3149 : home_export_lst_opt
3150 : : /* empty */
3151 : {
3152 0 : NON_DEV("home_export_lst_opt") ;
3153 : }
3154 0 : | home_export_lst
3155 : {
3156 0 : NON_DEV("home_export_lst_opt") ;
3157 : }
3158 0 : ;
3159 :
3160 : /* OMG Rule (130-c) */
3161 :
3162 : home_export_lst
3163 : : home_export
3164 : {
3165 0 : NON_DEV("home_export_lst") ;
3166 : }
3167 0 : | home_export_lst home_export
3168 : {
3169 0 : NON_DEV("home_export_lst") ;
3170 : }
3171 0 : ;
3172 :
3173 : /* OMG Rule (131) */
3174 :
3175 : home_export
3176 : : export
3177 : {
3178 0 : NON_DEV("home_export") ;
3179 : }
3180 0 : | factory_dcl
3181 : {
3182 0 : NON_DEV("home_export") ;
3183 : }
3184 0 : | finder_dcl
3185 : {
3186 0 : NON_DEV("home_export") ;
3187 : }
3188 0 : ;
3189 :
3190 : /* OMG Rule (132) */
3191 :
3192 : factory_dcl
3193 : : TOK_FACTORY TOK_IDENTIFIER
3194 : TOK_LEFT_PARENTHESIS init_param_decls_opt TOK_RIGHT_PARENTHESIS
3195 : raises_expr_opt
3196 : {
3197 0 : NON_DEV("factory_dcl") ;
3198 : }
3199 0 : ;
3200 :
3201 : /* OMG Rule (133) */
3202 :
3203 : finder_dcl
3204 : : TOK_FINDER TOK_IDENTIFIER
3205 : TOK_LEFT_PARENTHESIS init_param_decls_opt TOK_RIGHT_PARENTHESIS
3206 : raises_expr_opt
3207 : {
3208 0 : NON_DEV("finder_dcl") ;
3209 : }
3210 0 : ;
3211 :
3212 : /* OMG Rule (134) */
3213 :
3214 : event
3215 : : event_dcl
3216 : {
3217 0 : NON_DEV("event") ;
3218 : }
3219 0 : | event_abs_dcl
3220 : {
3221 0 : NON_DEV("event") ;
3222 : }
3223 0 : | event_forward_dcl
3224 : {
3225 0 : NON_DEV("event") ;
3226 : }
3227 0 : ;
3228 :
3229 : /* OMG Rule (135) */
3230 :
3231 : event_forward_dcl
3232 : : TOK_ABSTRACT TOK_EVENTTYPE TOK_IDENTIFIER
3233 : {
3234 0 : NON_DEV("event_forward_dcl") ;
3235 : }
3236 0 : | TOK_EVENTTYPE TOK_IDENTIFIER
3237 : {
3238 0 : NON_DEV("event_forward_dcl") ;
3239 : }
3240 0 : ;
3241 :
3242 : /* OMG Rule (136) */
3243 :
3244 : event_abs_dcl
3245 : : TOK_ABSTRACT TOK_EVENTTYPE TOK_IDENTIFIER
3246 : value_inheritance_spec_opt
3247 : TOK_LEFT_CURLY_BRAKET export_lst_opt TOK_RIGHT_CURLY_BRAKET
3248 : {
3249 0 : NON_DEV("event_abs_dcl") ;
3250 : }
3251 0 : ;
3252 :
3253 : /* OMG Rule (137) */
3254 :
3255 : event_dcl
3256 : : event_header
3257 : TOK_LEFT_CURLY_BRAKET value_element_lst_opt TOK_RIGHT_CURLY_BRAKET
3258 : {
3259 0 : NON_DEV("event_dcl") ;
3260 : }
3261 0 : ;
3262 :
3263 : /* OMG Rule (138) */
3264 :
3265 : event_header
3266 : : TOK_CUSTOM TOK_EVENTTYPE TOK_IDENTIFIER value_inheritance_spec_opt
3267 : {
3268 0 : NON_DEV("event_header") ;
3269 : }
3270 0 : | TOK_EVENTTYPE TOK_IDENTIFIER value_inheritance_spec_opt
3271 : {
3272 0 : NON_DEV("event_header") ;
3273 : }
3274 0 : ;
3275 :
3276 : /* BONUS : string concatenation is done by bison, not flex */
3277 :
3278 : string_literal
3279 : : string_literal_unit
3280 : {
3281 4 : $$ = $1 ;
3282 : }
3283 4 : | string_literal string_literal_unit
3284 : {
3285 : ASSERT($1 != NULL) ;
3286 : ASSERT($2 != NULL) ;
3287 :
3288 0 : *($1) += *($2) ;
3289 0 : delete $2 ;
3290 0 : $$ = $1 ;
3291 : }
3292 0 : ;
3293 :
3294 : wide_string_literal
3295 : : wide_string_literal_unit
3296 : {
3297 1 : $$ = $1 ;
3298 : }
3299 1 : | wide_string_literal wide_string_literal_unit
3300 : {
3301 : ASSERT($1 != NULL) ;
3302 : ASSERT($2 != NULL) ;
3303 :
3304 0 : *($1) += *($2) ;
3305 0 : delete $2 ;
3306 0 : $$ = $1 ;
3307 : }
3308 : ;
3309 :
3310 : /* END */
3311 :
3312 :
|
