| blob | 81fc6a05dd01963f30006a81e1b1008768461c2c |
1 /*
3 COPYRIGHT
5 Copyright 1992, 1993, 1994 Sun Microsystems, Inc. Printed in the United
6 States of America. All Rights Reserved.
8 This product is protected by copyright and distributed under the following
9 license restricting its use.
11 The Interface Definition Language Compiler Front End (CFE) is made
12 available for your use provided that you include this license and copyright
13 notice on all media and documentation and the software program in whichlong
14 this product is incorporated in whole or part. You may copy and extend
15 functionality (but may not remove functionality) of the Interface
16 Definition Language CFE without charge, but you are not authorized to
17 license or distribute it to anyone else except as part of a product or
18 program developed by you or with the express written consent of Sun
19 Microsystems, Inc. ("Sun").
21 The names of Sun Microsystems, Inc. and any of its subsidiaries or
22 affiliates may not be used in advertising or publicity pertaining to
23 distribution of Interface Definition Language CFE as permitted herein.
25 This license is effective until terminated by Sun for failure to comply
26 with this license. Upon termination, you shall destroy or return all code
27 and documentation for the Interface Definition Language CFE.
29 INTERFACE DEFINITION LANGUAGE CFE IS PROVIDED AS IS WITH NO WARRANTIES OF
30 ANY KIND INCLUDING THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS
31 FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR ARISING FROM A COURSE OF
32 DEALING, USAGE OR TRADE PRACTICE.
34 INTERFACE DEFINITION LANGUAGE CFE IS PROVIDED WITH NO SUPPORT AND WITHOUT
35 ANY OBLIGATION ON THE PART OF Sun OR ANY OF ITS SUBSIDIARIES OR AFFILIATES
36 TO ASSIST IN ITS USE, CORRECTION, MODIFICATION OR ENHANCEMENT.
38 SUN OR ANY OF ITS SUBSIDIARIES OR AFFILIATES SHALL HAVE NO LIABILITY WITH
39 RESPECT TO THE INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY
40 INTERFACE DEFINITION LANGUAGE CFE OR ANY PART THEREOF.
42 IN NO EVENT WILL SUN OR ANY OF ITS SUBSIDIARIES OR AFFILIATES BE LIABLE FOR
43 ANY LOST REVENUE OR PROFITS OR OTHER SPECIAL, INDIRECT AND CONSEQUENTIAL
44 DAMAGES, EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
46 Use, duplication, or disclosure by the government is subject to
47 restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in
48 Technical Data and Computer Software clause at DFARS 252.227-7013 and FAR
49 52.227-19.
51 Sun, Sun Microsystems and the Sun logo are trademarks or registered
52 trademarks of Sun Microsystems, Inc.
54 SunSoft, Inc.
55 2550 Garcia Avenue
56 Mountain View, California 94043
58 NOTE:
60 SunOS, SunSoft, Sun, Solaris, Sun Microsystems or the Sun logo are
61 trademarks or registered trademarks of Sun Microsystems, Inc.
63 */
65 /**
66 * \file idl.ypp
67 * \brief Bison grammar for IDL
68 */
70 /* Declarations */
72 %{
73 #include <utl_identifier.h>
74 #include <utl_err.h>
75 #include <utl_string.h>
76 #include <utl_strlist.h>
77 #include <utl_namelist.h>
78 #include <utl_exprlist.h>
79 #include <utl_labellist.h>
80 #include <utl_decllist.h>
82 #include <global_extern.h>
83 #include <nr_extern.h>
85 #include <ast_argument.h>
86 #include <ast_array.h>
87 #include <ast_attribute.h>
88 #include <ast_field.h>
89 #include <ast_fixed.h>
90 #include <ast_expression.h>
91 #include <ast_operation.h>
92 #include <ast_generator.h>
93 #include <ast_template_module.h>
94 #include <ast_template_module_inst.h>
95 #include <ast_template_module_ref.h>
96 #include <ast_typedef.h>
97 #include <ast_valuebox.h>
98 #include <ast_valuetype.h>
99 #include <ast_valuetype_fwd.h>
100 #include <ast_eventtype.h>
101 #include <ast_eventtype_fwd.h>
102 #include <ast_component.h>
103 #include <ast_component_fwd.h>
104 #include <ast_home.h>
105 #include <ast_porttype.h>
106 #include <ast_connector.h>
107 #include <ast_uses.h>
108 #include <ast_constant.h>
109 #include <ast_union.h>
110 #include <ast_union_fwd.h>
111 #include <ast_structure_fwd.h>
112 #include <ast_extern.h>
113 #include <ast_enum.h>
114 #include <ast_root.h>
115 #include <ast_sequence.h>
116 #include <ast_string.h>
117 #include <ast_factory.h>
118 #include <ast_finder.h>
119 #include <ast_exception.h>
120 #include <ast_param_holder.h>
121 #include <ast_visitor_tmpl_module_inst.h>
122 #include <ast_visitor_tmpl_module_ref.h>
123 #include <ast_visitor_context.h>
124 #include <ast_annotation_appl.h>
125 #include <ast_union_branch.h>
126 #include <ast_enum_val.h>
127 #include <ast_annotation_member.h>
128 #include <ast_provides.h>
129 #include <ast_emits.h>
130 #include <ast_publishes.h>
131 #include <ast_consumes.h>
132 #include <ast_extended_port.h>
133 #include <ast_mirror_port.h>
135 #include <fe_declarator.h>
136 #include <fe_interface_header.h>
137 #include <fe_obv_header.h>
138 #include <fe_component_header.h>
139 #include <fe_home_header.h>
140 #include <fe_utils.h>
142 void tao_yyerror (const char *);
143 int tao_yylex (void);
144 extern "C" int tao_yywrap (void);
146 extern char tao_yytext[];
147 extern int tao_yyleng;
149 AST_Enum *tao_enum_constant_decl = 0;
150 AST_String *tao_string_decl = 0;
151 AST_Expression::ExprType t_param_const_type = AST_Expression::EV_none;
152 bool stack_based_lookup_for_primary_expr = false;
154 #define TAO_YYDEBUG_LEXER_TEXT (tao_yytext[tao_yyleng] = '\0', tao_yytext)
155 // Compile Optional Tracing Output for Parser, can be enabled with --bison-trace
156 #define YYDEBUG 1
157 %}
159 /*
160 * Declare the type of values in the grammar
161 */
163 %union {
164 AST_Decl *dcval; /* Decl value */
165 UTL_StrList *slval; /* String list */
166 UTL_NameList *nlval; /* Name list */
167 UTL_ExprList *elval; /* Expression list */
168 UTL_LabelList *llval; /* Label list */
169 UTL_DeclList *dlval; /* Declaration list */
170 FE_InterfaceHeader *ihval; /* Interface header */
171 FE_OBVHeader *vhval; /* Valuetype header */
172 FE_ComponentHeader *chval; /* Component header */
173 FE_HomeHeader *hhval; /* Home header */
174 AST_Expression *exval; /* Expression value */
175 AST_UnionLabel *ulval; /* Union label */
176 AST_Field *ffval; /* Field value */
177 AST_Field::Visibility vival; /* N/A, pub or priv */
178 AST_Expression::ExprType etval; /* Expression type */
179 AST_Argument::Direction dival; /* Argument direction */
180 AST_Operation::Flags ofval; /* Operation flags */
181 FE_Declarator *deval; /* Declarator value */
182 ACE_CDR::Boolean bval; /* Boolean value */
183 ACE_CDR::LongLong ival; /* Long Long value */
184 ACE_CDR::ULongLong uival; /* Unsigned long long */
185 ACE_CDR::Double dval; /* Double value */
186 ACE_CDR::Float fval; /* Float value */
187 ACE_CDR::Char cval; /* Char value */
188 ACE_CDR::WChar wcval; /* WChar value */
189 ACE_CDR::Fixed fixval; /* Fixed point value */
190 UTL_String *sval; /* String value */
191 char *wsval; /* WString value */
192 char *strval; /* char * value */
193 Identifier *idval; /* Identifier */
194 UTL_IdList *idlist; /* Identifier list */
195 AST_Decl::NodeType ntval; /* Node type value */
196 FE_Utils::T_Param_Info *pival; /* Template interface param */
197 FE_Utils::T_PARAMLIST_INFO *plval; /* List of template params */
198 FE_Utils::T_ARGLIST *alval; /* List of template args */
199 AST_Annotation_Appl *annotation_val;
200 AST_Annotation_Appls *annotations_val;
201 AST_Annotation_Appl::Param *annotation_param_val;
202 AST_Annotation_Appl::Params *annotation_params_val;
203 AST_Annotation_Decl *annotation_decl_val;
204 AST_Decls *decls_val;
205 Decl_Annotations_Pair *decl_annotations_pair_val;
206 }
208 /*
209 * Token types: These are returned by the lexer
210 */
212 %token <strval> IDENTIFIER
214 %token IDL_CONST
215 %token IDL_MODULE
216 %token IDL_INTERFACE
217 %token IDL_TYPEDEF
218 %token IDL_LONG
219 %token IDL_SHORT
220 %token IDL_UNSIGNED
221 %token IDL_DOUBLE
222 %token IDL_FLOAT
223 %token IDL_CHAR
224 %token IDL_WCHAR
225 %token IDL_OCTET
226 %token IDL_BOOLEAN
227 %token IDL_FIXED
228 %token IDL_ANY
229 %token IDL_OBJECT
230 %token IDL_STRUCT
231 %token IDL_UNION
232 %token IDL_SWITCH
233 %token IDL_ENUM
234 %token IDL_SEQUENCE
235 %token IDL_STRING
236 %token IDL_WSTRING
237 %token IDL_EXCEPTION
238 %token IDL_CASE
239 %token IDL_DEFAULT
240 %token IDL_READONLY
241 %token IDL_ATTRIBUTE
242 %token IDL_ONEWAY
243 %token IDL_IDEMPOTENT
244 %token IDL_VOID
245 %token IDL_IN
246 %token IDL_OUT
247 %token IDL_INOUT
248 %token IDL_RAISES
249 %token IDL_CONTEXT
250 %token IDL_NATIVE
251 %token IDL_LOCAL
252 /* OBV tokens */
253 %token IDL_ABSTRACT
254 %token IDL_CUSTOM
255 %token IDL_FACTORY
256 %token IDL_PRIVATE
257 %token IDL_PUBLIC
258 %token IDL_SUPPORTS
259 %token IDL_TRUNCATABLE
260 %token IDL_VALUETYPE
261 /* Component tokens */
262 %token IDL_COMPONENT
263 %token IDL_CONSUMES
264 %token IDL_EMITS
265 %token IDL_EVENTTYPE
266 %token IDL_FINDER
267 %token IDL_GETRAISES
268 %token IDL_HOME
269 %token IDL_IMPORT
270 %token IDL_MULTIPLE
271 %token IDL_PRIMARYKEY
272 %token IDL_PROVIDES
273 %token IDL_PUBLISHES
274 %token IDL_SETRAISES
275 %token IDL_TYPEID
276 %token IDL_TYPEPREFIX
277 %token IDL_USES
278 %token IDL_MANAGES
279 /* Extended ports tokens */
280 %token IDL_TYPENAME
281 %token IDL_PORT
282 %token IDL_MIRRORPORT
283 %token IDL_PORTTYPE
284 %token IDL_CONNECTOR
285 %token IDL_ALIAS
287 %token <ival> IDL_INTEGER_LITERAL
288 %token <uival> IDL_UINTEGER_LITERAL
289 %token <sval> IDL_STRING_LITERAL
290 %token <cval> IDL_CHARACTER_LITERAL
291 %token <dval> IDL_FLOATING_PT_LITERAL
292 %token <fixval> IDL_FIXED_PT_LITERAL
293 %token IDL_TRUETOK
294 %token IDL_FALSETOK
296 /* stdint like types defined in IDL4.2 7.4.13 */
297 %token IDL_INT8
298 %token IDL_UINT8
299 %token IDL_INT16
300 %token IDL_UINT16
301 %token IDL_INT32
302 %token IDL_UINT32
303 %token IDL_INT64
304 %token IDL_UINT64
306 %token <strval> IDL_SCOPE_DELIMITOR
307 %token IDL_LEFT_SHIFT
308 %token IDL_RIGHT_SHIFT
309 %token <wcval> IDL_WCHAR_LITERAL
310 %token <wsval> IDL_WSTRING_LITERAL
312 %token IDL_ANNOTATION_DECL
313 %token IDL_ANNOTATION_SYMBOL
315 /*
316 * These are production names:
317 */
319 %type <dcval> type_spec simple_type_spec constructed_type_spec
320 %type <dcval> template_type_spec sequence_type_spec string_type_spec
321 %type <dcval> struct_type enum_type switch_type_spec union_type
322 %type <dcval> array_declarator op_type_spec wstring_type_spec
323 %type <dcval> param_type_spec type_dcl type_declarator actual_parameter
324 %type <dcval> fixed_type_spec
325 %type <dcval> definition fixed_definition module const_dcl struct_forward_type
326 %type <dcval> interface_def interface interface_forward
327 %type <dcval> export operation attribute attribute_readonly attribute_readwrite
328 %type <dcval> template_module template_module_inst annotation_dcl typeid_dcl
329 %type <dcval> typeprefix_dcl exception component home_decl
330 %type <dcval> event_decl event_abs_decl event_forward_decl
331 %type <dcval> event_abs_forward_decl event_concrete_forward_decl
332 %type <dcval> porttype_decl connector_decl value_def
333 %type <dcval> valuetype value_abs_decl value_forward_decl value_box_decl
334 %type <dcval> value_concrete_decl component_forward_decl component_decl
335 %type <dcval> init_decl provides_decl uses_decl port_export
336 %type <dcval> component_export emits_decl publishes_decl consumes_decl
337 %type <dcval> extended_port_decl
339 %type <idlist> scoped_name interface_type component_inheritance_spec
340 %type <idlist> home_inheritance_spec primary_key_spec module_header
341 %type <idlist> template_module_header
343 %type <slval> opt_context at_least_one_string_literal
344 %type <slval> string_literals formal_parameter_names
345 %type <slval> at_least_one_formal_parameter_name
347 %type <nlval> at_least_one_scoped_name scoped_names inheritance_spec
348 %type <nlval> opt_raises opt_getraises opt_setraises supports_spec
350 %type <elval> at_least_one_array_dim array_dims
352 %type <llval> at_least_one_case_label case_labels
354 %type <dlval> at_least_one_declarator declarators
355 %type <dlval> at_least_one_simple_declarator simple_declarators
357 %type <ihval> interface_header
359 %type <vhval> value_header event_rest_of_header
361 %type <chval> component_header
363 %type <hhval> home_header
365 %type <exval> expression const_expr or_expr xor_expr and_expr shift_expr
366 %type <exval> add_expr mult_expr unary_expr primary_expr literal
367 %type <exval> positive_int_expr array_dim annotation_member_default
369 %type <ulval> case_label
371 %type <ffval> element_spec
373 %type <etval> const_type integer_type char_type boolean_type
374 %type <etval> floating_pt_type fixed_type any_type signed_int
375 %type <etval> unsigned_int base_type_spec octet_type object_type
376 %type <etval> annotation_member_type
378 %type <dival> direction
380 %type <ofval> opt_op_attribute
382 %type <deval> declarator simple_declarator complex_declarator
384 %type <bval> opt_truncatable opt_multiple uses_opt_multiple
386 %type <idval> interface_decl value_decl union_decl struct_decl id
387 %type <idval> defining_id
388 %type <idval> event_header event_plain_header event_custom_header
389 %type <idval> event_abs_header
391 %type <ntval> formal_parameter_type
393 %type <pival> formal_parameter
394 %type <plval> formal_parameters at_least_one_formal_parameter
396 %type <sval> formal_parameter_name
398 %type <alval> actual_parameters at_least_one_actual_parameter
400 %type <annotations_val> at_least_one_annotation annotations_maybe
401 %type <annotation_val> annotation_appl
402 %type <annotation_params_val> annotation_appl_params_maybe annotation_appl_params
403 %type <annotation_params_val> named_annotation_appl_params more_named_annotation_appl_params
404 %type <annotation_param_val> named_annotation_appl_param
405 %type <decl_annotations_pair_val> seq_head
407 %type <decls_val> member_i state_member value_element
408 %type <vival> visibility
409 %%
411 /*
412 * Production starts here.
413 */
414 start : definitions ;
416 definitions
417 : at_least_one_definition
418 | %empty
419 ;
421 at_least_one_definition
422 /*
423 * This is broken up into 2 rules to avoid a grammer ambiguity which
424 * manifests as bison complaining about shift/reduce conflicts.
425 */
426 : definitions at_least_one_annotation definition
427 {
428 AST_Annotation_Appls *&annotations = $2;
429 AST_Decl *&node = $3;
430 if (node)
431 {
432 node->annotation_appls (*annotations);
433 }
434 else
435 {
436 idl_global->err ()-> unsupported_warning (
437 "Annotating this is not supported");
438 }
439 delete annotations;
440 }
441 | definitions definition
442 ;
444 definition
445 : fixed_definition
446 | template_module ';'
447 | template_module_inst ';'
448 ;
450 fixed_definition
451 : annotation_dcl
452 {
453 idl_global->set_parse_state (IDL_GlobalData::PS_AnnotationDeclSeen);
454 }
455 ';'
456 {
457 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
458 }
459 | type_dcl
460 {
461 idl_global->set_parse_state (IDL_GlobalData::PS_TypeDeclSeen);
462 }
463 ';'
464 {
465 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
466 }
467 | typeid_dcl
468 {
469 idl_global->set_parse_state (IDL_GlobalData::PS_TypeIdDeclSeen);
470 }
471 ';'
472 {
473 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
474 }
475 | typeprefix_dcl
476 {
477 idl_global->set_parse_state (IDL_GlobalData::PS_TypePrefixDeclSeen);
478 }
479 ';'
480 {
481 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
482 }
483 | const_dcl
484 {
485 idl_global->set_parse_state (IDL_GlobalData::PS_ConstDeclSeen);
486 }
487 ';'
488 {
489 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
490 }
491 | exception
492 {
493 idl_global->set_parse_state (IDL_GlobalData::PS_ExceptDeclSeen);
494 }
495 ';'
496 {
497 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
498 }
499 | interface_def
500 {
501 idl_global->set_parse_state (IDL_GlobalData::PS_InterfaceDeclSeen);
502 }
503 ';'
504 {
505 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
506 }
507 | module
508 {
509 idl_global->set_parse_state (IDL_GlobalData::PS_ModuleDeclSeen);
510 }
511 ';'
512 {
513 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
514 }
515 | value_def
516 {
517 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeDeclSeen);
518 }
519 ';'
520 {
521 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
522 }
523 | component
524 {
525 idl_global->set_parse_state (IDL_GlobalData::PS_ComponentDeclSeen);
526 }
527 ';'
528 {
529 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
530 }
531 | home_decl
532 {
533 idl_global->set_parse_state (IDL_GlobalData::PS_HomeDeclSeen);
534 }
535 ';'
536 {
537 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
538 }
539 | event
540 {
541 idl_global->set_parse_state (IDL_GlobalData::PS_EventDeclSeen);
542 }
543 ';'
544 {
545 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
546 }
547 | porttype_decl
548 {
549 idl_global->set_parse_state (IDL_GlobalData::PS_PorttypeDeclSeen);
550 }
551 ';'
552 {
553 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
554 }
555 | connector_decl
556 {
557 idl_global->set_parse_state (IDL_GlobalData::PS_ConnectorDeclSeen);
558 }
559 ';'
560 {
561 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
562 }
563 | error
564 {
565 idl_global->err ()->syntax_error (idl_global->parse_state ());
566 }
567 ';'
568 {
569 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
570 yyerrok;
571 $$ = 0;
572 }
573 ;
575 module_header
576 : IDL_MODULE
577 {
578 idl_global->set_parse_state (IDL_GlobalData::PS_ModuleSeen);
579 }
580 scoped_name
581 {
582 $<idlist>$ = $3;
583 }
584 ;
586 module
587 : module_header
588 {
589 idl_global->set_parse_state (IDL_GlobalData::PS_ModuleIDSeen);
591 // The module_header rule is common to template module, fixed
592 // module and instantiated template module. In the last
593 // case, a fully scoped name is allowed, but here we
594 // allow only an identifier (a scoped name of length
595 // 1). If not satisfied, we output a parse error with
596 // the appropriate message.
597 if ($1->length () != 1)
598 {
599 idl_global->err ()->syntax_error (
600 IDL_GlobalData::PS_ModuleIDSeen);
601 }
603 AST_Module *m = 0;
604 UTL_Scope *s = idl_global->scopes ().top_non_null ();
606 /*
607 * Make a new module and add it to the enclosing scope
608 */
609 if (s != 0)
610 {
611 m = idl_global->gen ()->create_module (s, $1);
612 (void) s->fe_add_module (m);
613 }
615 $1->destroy ();
616 delete $1;
617 $1 = 0;
619 /*
620 * Push it on the stack
621 */
622 idl_global->scopes ().push (m);
624 $<dcval>$ = m;
625 }
626 '{'
627 {
628 idl_global->set_parse_state (IDL_GlobalData::PS_ModuleSqSeen);
629 }
630 at_least_one_definition
631 {
632 idl_global->set_parse_state (IDL_GlobalData::PS_ModuleBodySeen);
633 }
634 '}'
635 {
636 idl_global->set_parse_state (IDL_GlobalData::PS_ModuleQsSeen);
637 /*
638 * Finished with this module - pop it from the scope stack.
639 */
641 idl_global->scopes ().pop ();
642 $$ = $<dcval>2;
643 }
644 ;
646 template_module_header
647 : module_header '<'
648 {
649 idl_global->set_parse_state (IDL_GlobalData::PS_TmplModuleIDSeen);
650 }
651 ;
653 template_module
654 : template_module_header
655 {
656 // The module_header rule is common to template module, fixed
657 // module and instantiated template module. In the last
658 // case, a fully scoped name is allowed, but here we
659 // allow only an identifier (a scoped name of length
660 // 1). If not satisfied, we output a syntax error with
661 // the appropriate message.
662 if ($1->length () != 1)
663 {
664 idl_global->err ()->syntax_error (
665 IDL_GlobalData::PS_ModuleIDSeen);
666 }
667 }
668 at_least_one_formal_parameter
669 {
670 if (FE_Utils::duplicate_param_id ($3))
671 {
672 idl_global->err ()->duplicate_param_id (
673 $1);
675 return 1;
676 }
677 }
678 '>'
679 {
680 idl_global->set_parse_state (IDL_GlobalData::PS_TmplModuleParamsSeen);
682 AST_Template_Module *tm =
683 idl_global->gen ()->create_template_module ($1,
684 $3);
686 UTL_Scope *s = idl_global->scopes ().top_non_null ();
687 AST_Module *m = s->fe_add_module (tm);
689 // We've probably tried to reopen a template module,
690 // going further will cause a crash.
691 if (m == 0)
692 {
693 return 1;
694 }
696 /*
697 * Push it on the stack
698 */
699 idl_global->scopes ().push (tm);
701 // Contained items not part of an alias will get flag set.
702 idl_global->in_tmpl_mod_no_alias (true);
704 // Store these for reference as we parse the scope
705 // of the template module.
706 idl_global->current_params ($3);
707 }
708 '{'
709 {
710 idl_global->set_parse_state (IDL_GlobalData::PS_TmplModuleSqSeen);
711 }
712 at_least_one_tpl_definition
713 {
714 idl_global->set_parse_state (IDL_GlobalData::PS_TmplModuleBodySeen);
715 }
716 '}'
717 {
718 idl_global->set_parse_state (IDL_GlobalData::PS_TmplModuleQsSeen);
720 /*
721 * Finished with this module - pop it from the scope stack.
722 */
723 idl_global->scopes ().pop ();
725 // Unset the flag, the no_alias version because any scope
726 // traversal triggered by an alias would have ended by now.
727 idl_global->in_tmpl_mod_no_alias (false);
729 // Clear the pointer so scoped name lookup will know
730 // that we are no longer in a template module scope.
731 idl_global->current_params (0);
733 $$ = 0;
734 }
735 ;
737 at_least_one_tpl_definition
738 : tpl_definition tpl_definitions
739 ;
741 tpl_definitions
742 : tpl_definitions tpl_definition
743 | %empty
744 ;
746 tpl_definition
747 : fixed_definition
748 | template_module_ref ';'
749 ;
751 template_module_ref
752 : IDL_ALIAS scoped_name
753 {
754 idl_global->set_parse_state (
755 IDL_GlobalData::PS_ModuleRefSeen);
756 }
757 '<' at_least_one_formal_parameter_name '>'
758 {
759 idl_global->set_parse_state (
760 IDL_GlobalData::PS_ModuleRefParamsSeen);
761 }
762 defining_id
763 {
764 idl_global->set_parse_state (
765 IDL_GlobalData::PS_ModuleRefIDSeen);
767 UTL_Scope *s = idl_global->scopes ().top_non_null ();
768 AST_Decl *d =
769 s->lookup_by_name ($2);
771 if (d == 0)
772 {
773 idl_global->err ()->lookup_error ($2);
774 return 1;
775 }
777 AST_Template_Module *ref =
778 dynamic_cast<AST_Template_Module*> (d);
780 if (ref == 0)
781 {
782 idl_global->err ()->template_module_expected (d);
783 return 1;
784 }
786 bool refs_match =
787 ref->match_param_refs ($5,
788 s);
790 if (! refs_match)
791 {
792 // Error message is already output.
793 return 1;
794 }
796 UTL_ScopedName sn ($8, 0);
798 AST_Template_Module_Ref *tmr =
799 idl_global->gen ()->create_template_module_ref (
800 &sn,
801 ref,
802 $5);
804 (void) s->fe_add_template_module_ref (tmr);
806 sn.destroy ();
807 $2->destroy ();
808 delete $2;
809 $2 = 0;
811 // Save the current flag value to be restored below.
812 bool itmna_flag = idl_global->in_tmpl_mod_no_alias ();
813 idl_global->in_tmpl_mod_no_alias (false);
814 idl_global->in_tmpl_mod_alias (true);
816 ast_visitor_context ctx;
817 ctx.template_params (ref->template_params ());
818 ast_visitor_tmpl_module_ref v (&ctx);
820 // The implied IDL resulting from this reference is
821 // created here, in the template module scope. Upon
822 // instantiation of the enclosing template module, the
823 // visitor copies this implied IDL to the instantiated
824 // module scope. The extra copy is less than ideal, but
825 // otherwise we have ugly lookup issues when the
826 // referenced template module's contents are referenced
827 // using the aliased scoped name.
828 if (v.visit_template_module_ref (tmr) != 0)
829 {
830 ACE_ERROR ((LM_ERROR,
831 ACE_TEXT ("visit_template_module_ref")
832 ACE_TEXT (" failed\n")));
834 idl_global->set_err_count (idl_global->err_count () + 1);
835 }
837 idl_global->in_tmpl_mod_no_alias (itmna_flag);
838 idl_global->in_tmpl_mod_alias (false);
839 }
840 ;
842 template_module_inst
843 : template_module_header
844 {
845 idl_global->set_parse_state (
846 IDL_GlobalData::PS_InstModuleSeen);
847 }
848 at_least_one_actual_parameter '>'
849 {
850 idl_global->set_parse_state (
851 IDL_GlobalData::PS_InstModuleArgsSeen);
852 }
853 defining_id
854 {
855 idl_global->set_parse_state (
856 IDL_GlobalData::PS_InstModuleIDSeen);
858 UTL_Scope *s = idl_global->scopes ().top_non_null ();
859 UTL_ScopedName *sn = $1;
860 AST_Template_Module *ref = 0;
861 AST_Decl *d = s->lookup_by_name (sn);
863 if (d == 0)
864 {
865 idl_global->err ()->lookup_error (sn);
866 return 1;
867 }
868 else
869 {
870 ref = dynamic_cast<AST_Template_Module*> (d);
872 if (ref == 0)
873 {
874 idl_global->err ()->template_module_expected (d);
875 return 1;
876 }
877 }
879 sn->destroy ();
880 delete sn;
881 sn = 0;
882 $1 = 0;
884 if (! ref->match_arg_names ($3))
885 {
886 return 1;
887 }
889 ACE_NEW_RETURN (sn,
890 UTL_ScopedName ($6,
891 0),
892 1);
894 AST_Template_Module_Inst *tmi =
895 idl_global->gen ()->create_template_module_inst (
896 sn,
897 ref,
898 $3);
900 (void) s->fe_add_template_module_inst (tmi);
902 ast_visitor_context ctx;
903 ctx.template_args ($3);
904 ast_visitor_tmpl_module_inst v (&ctx);
906 if (v.visit_template_module_inst (tmi) != 0)
907 {
908 ACE_ERROR ((LM_ERROR,
909 ACE_TEXT ("visit_template_module_inst")
910 ACE_TEXT (" failed\n")));
912 idl_global->set_err_count (idl_global->err_count () + 1);
913 }
915 $$ = 0;
916 }
917 ;
919 interface_def
920 : interface
921 | interface_forward
922 ;
924 interface
925 : interface_header
926 {
927 UTL_Scope *s = idl_global->scopes ().top_non_null ();
928 AST_Interface *i = 0;
930 FE_InterfaceHeader *header = $1;
931 $1 = 0;
933 /*
934 * Make a new interface node and add it to its enclosing scope.
935 */
936 if (s && header)
937 {
938 i = idl_global->gen ()->create_interface (
939 header->name (),
940 header->inherits (),
941 header->n_inherits (),
942 header->inherits_flat (),
943 header->n_inherits_flat (),
944 header->is_local (),
945 header->is_abstract ()
946 );
947 AST_Interface::fwd_redefinition_helper (i, s);
948 /*
949 * Add the interface to its definition scope.
950 */
951 s->fe_add_interface (i);
953 // This FE_InterfaceHeader class isn't destroyed with the AST.
954 header->destroy ();
955 delete header;
956 }
958 /*
959 * Push it on the scope stack.
960 */
961 idl_global->scopes ().push (i);
962 }
963 '{'
964 {
965 idl_global->set_parse_state (IDL_GlobalData::PS_InterfaceSqSeen);
966 }
967 exports
968 {
969 idl_global->set_parse_state (IDL_GlobalData::PS_InterfaceBodySeen);
970 }
971 '}'
972 {
973 idl_global->set_parse_state (IDL_GlobalData::PS_InterfaceQsSeen);
975 $$ = dynamic_cast<AST_Decl *> (idl_global->scopes ().top_non_null ());
976 /*
977 * Done with this interface - pop it off the scopes stack
978 */
979 idl_global->scopes ().pop ();
980 }
981 ;
983 interface_decl:
984 IDL_INTERFACE
985 {
986 idl_global->set_parse_state (IDL_GlobalData::PS_InterfaceSeen);
987 }
988 defining_id
989 {
990 idl_global->set_parse_state (IDL_GlobalData::PS_InterfaceIDSeen);
991 $$ = $3;
992 }
993 ;
995 interface_header :
996 interface_decl inheritance_spec
997 {
998 idl_global->set_parse_state (IDL_GlobalData::PS_InheritSpecSeen);
1000 if ($2 != 0 && $2->truncatable ())
1001 {
1002 idl_global->err ()->syntax_error (
1003 IDL_GlobalData::PS_InheritColonSeen
1004 );
1005 }
1007 /*
1008 * Create an AST representation of the information in the header
1009 * part of an interface - this representation contains a computed
1010 * list of all interfaces which this interface inherits from,
1011 * recursively
1012 */
1013 UTL_ScopedName *n = 0;
1014 ACE_NEW_RETURN (n,
1015 UTL_ScopedName ($1, 0),
1016 1);
1017 ACE_NEW_RETURN ($$,
1018 FE_InterfaceHeader (n,
1019 $2,
1020 false,
1021 false,
1022 true),
1023 1);
1025 if (0 != $2)
1026 {
1027 $2->destroy ();
1028 delete $2;
1029 $2 = 0;
1030 }
1031 }
1032 |
1033 IDL_LOCAL interface_decl inheritance_spec
1034 {
1035 idl_global->set_parse_state (IDL_GlobalData::PS_InheritSpecSeen);
1037 /*
1038 * Create an AST representation of the information in the header
1039 * part of an interface - this representation contains a computed
1040 * list of all interfaces which this interface inherits from,
1041 * recursively
1042 */
1043 UTL_ScopedName *n = 0;
1044 ACE_NEW_RETURN (n,
1045 UTL_ScopedName ($2, 0),
1046 1);
1047 ACE_NEW_RETURN ($$,
1048 FE_InterfaceHeader (n,
1049 $3,
1050 true,
1051 false,
1052 true),
1053 1);
1055 if (0 != $3)
1056 {
1057 $3->destroy ();
1058 delete $3;
1059 $3 = 0;
1060 }
1061 }
1062 |
1063 IDL_ABSTRACT interface_decl inheritance_spec
1064 {
1065 idl_global->set_parse_state (IDL_GlobalData::PS_InheritSpecSeen);
1067 /*
1068 * Create an AST representation of the information in the header
1069 * part of an interface - this representation contains a computed
1070 * list of all interfaces which this interface inherits from,
1071 * recursively
1072 */
1073 UTL_ScopedName *n = 0;
1074 ACE_NEW_RETURN (n,
1075 UTL_ScopedName ($2, 0),
1076 1);
1077 ACE_NEW_RETURN ($$,
1078 FE_InterfaceHeader (n,
1079 $3,
1080 false,
1081 true,
1082 true),
1083 1);
1085 if (0 != $3)
1086 {
1087 $3->destroy ();
1088 delete $3;
1089 $3 = 0;
1090 }
1091 }
1092 ;
1094 inheritance_spec
1095 : ':' opt_truncatable
1096 {
1097 idl_global->set_parse_state (IDL_GlobalData::PS_InheritColonSeen);
1098 }
1099 at_least_one_scoped_name
1100 {
1101 $4->truncatable ($2);
1102 $$ = $4;
1103 }
1104 | %empty
1105 {
1106 $$ = 0;
1107 }
1108 ;
1110 value_def
1111 : valuetype
1112 | value_abs_decl
1113 | value_forward_decl
1114 | value_box_decl
1115 ;
1117 valuetype
1118 : IDL_CUSTOM value_concrete_decl
1119 {
1120 idl_global->err ()->unsupported_error ("custom is not supported");
1121 $<dcval>$ = $2;
1122 }
1123 | value_concrete_decl
1124 ;
1126 value_concrete_decl :
1127 value_header
1128 {
1129 FE_OBVHeader *&valuetype_header = $1;
1130 UTL_Scope *scope = idl_global->scopes ().top_non_null ();
1131 AST_ValueType *valuetype = 0;
1133 if (scope && valuetype_header)
1134 {
1135 valuetype = idl_global->gen ()->create_valuetype (
1136 valuetype_header->name (),
1137 valuetype_header->inherits (),
1138 valuetype_header->n_inherits (),
1139 valuetype_header->inherits_concrete (),
1140 valuetype_header->inherits_flat (),
1141 valuetype_header->n_inherits_flat (),
1142 valuetype_header->supports (),
1143 valuetype_header->n_supports (),
1144 valuetype_header->supports_concrete (),
1145 false,
1146 valuetype_header->truncatable (),
1147 false);
1149 AST_Interface *valuetype_as_interface =
1150 dynamic_cast<AST_Interface *> (valuetype);
1151 AST_Interface::fwd_redefinition_helper (
1152 valuetype_as_interface, scope);
1153 valuetype = dynamic_cast<AST_ValueType *> (
1154 valuetype_as_interface);
1156 /*
1157 * Add the valuetype to its definition scope
1158 */
1159 scope->fe_add_valuetype (valuetype);
1161 // FE_OBVHeader is not automatically destroyed in the AST
1162 valuetype_header->destroy ();
1163 delete valuetype_header;
1164 valuetype_header = 0;
1165 }
1167 /*
1168 * Push it on the scope stack
1169 */
1170 idl_global->scopes ().push (valuetype);
1172 $<dcval>$ = valuetype;
1173 }
1174 '{'
1175 {
1176 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeSqSeen);
1177 }
1178 value_elements
1179 {
1180 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeBodySeen);
1181 }
1182 '}'
1183 {
1184 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeQsSeen);
1186 AST_ValueType *vt =
1187 dynamic_cast<AST_ValueType*> (
1188 idl_global->scopes ().top_non_null ()
1189 );
1191 if (vt != 0 && vt->will_have_factory ())
1192 {
1193 idl_global->valuefactory_seen_ = true;
1194 }
1196 /*
1197 * Done with this value type - pop it off the scopes stack
1198 */
1199 idl_global->scopes ().pop ();
1201 $$ = $<dcval>2;
1202 }
1203 ;
1205 value_abs_decl :
1206 IDL_ABSTRACT
1207 value_header
1208 {
1209 UTL_Scope *s = idl_global->scopes ().top_non_null ();
1210 AST_ValueType *v = 0;
1211 AST_Interface *i = 0;
1213 if (s != 0 && $2 != 0)
1214 {
1215 v =
1216 idl_global->gen ()->create_valuetype (
1217 $2->name (),
1218 $2->inherits (),
1219 $2->n_inherits (),
1220 $2->inherits_concrete (),
1221 $2->inherits_flat (),
1222 $2->n_inherits_flat (),
1223 $2->supports (),
1224 $2->n_supports (),
1225 $2->supports_concrete (),
1226 true,
1227 false,
1228 false
1229 );
1230 i = dynamic_cast<AST_Interface*> (v);
1231 AST_Interface::fwd_redefinition_helper (i,
1232 s);
1233 /*
1234 * Add the valuetype to its definition scope
1235 */
1236 v = dynamic_cast<AST_ValueType*> (i);
1237 (void) s->fe_add_valuetype (v);
1239 // FE_OBVHeader is not automatically destroyed in the AST
1240 $2->destroy ();
1241 delete $2;
1242 $2 = 0;
1243 }
1245 /*
1246 * Push it on the scope stack.
1247 */
1248 idl_global->scopes ().push (v);
1249 }
1250 '{'
1251 {
1252 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeSqSeen);
1253 }
1254 exports
1255 {
1256 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeBodySeen);
1257 }
1258 '}'
1259 {
1260 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeQsSeen);
1262 /*
1263 * Done with this valuetype - pop it off the scopes stack.
1264 */
1265 idl_global->scopes ().pop ();
1267 $$ = 0;
1268 }
1269 ;
1271 value_header :
1272 value_decl
1273 inheritance_spec
1274 {
1275 idl_global->set_parse_state (IDL_GlobalData::PS_InheritSpecSeen);
1276 }
1277 supports_spec
1278 {
1279 idl_global->set_parse_state (IDL_GlobalData::PS_SupportSpecSeen);
1281 UTL_ScopedName *sn = 0;
1282 ACE_NEW_RETURN (sn,
1283 UTL_ScopedName ($1, 0),
1284 1);
1285 ACE_NEW_RETURN ($$,
1286 FE_OBVHeader (sn,
1287 $2,
1288 $4,
1289 ($2 != 0
1290 ? $2->truncatable ()
1291 : false)),
1292 1);
1294 if (0 != $4)
1295 {
1296 $4->destroy ();
1297 delete $4;
1298 $4 = 0;
1299 }
1301 if (0 != $2)
1302 {
1303 $2->destroy ();
1304 delete $2;
1305 $2 = 0;
1306 }
1307 }
1308 ;
1310 value_decl
1311 : IDL_VALUETYPE
1312 {
1313 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeSeen);
1314 }
1315 defining_id
1316 {
1317 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeIDSeen);
1318 $$ = $3;
1319 }
1320 ;
1322 opt_truncatable :
1323 IDL_TRUNCATABLE
1324 {
1325 $$ = true;
1326 }
1327 | %empty
1328 {
1329 $$ = false;
1330 }
1331 ;
1333 supports_spec :
1334 IDL_SUPPORTS
1335 at_least_one_scoped_name
1336 {
1337 $$ = $2;
1338 }
1339 | %empty
1340 {
1341 $$ = 0;
1342 }
1343 ;
1345 value_forward_decl :
1346 IDL_ABSTRACT
1347 value_decl
1348 {
1349 UTL_Scope *s = idl_global->scopes ().top_non_null ();
1350 UTL_ScopedName n ($2,
1351 0);
1352 AST_ValueTypeFwd *f = 0;
1353 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeForwardSeen);
1355 /*
1356 * Create a node representing a forward declaration of an
1357 * valuetype. Store it in the enclosing scope
1358 */
1359 if (s != 0)
1360 {
1361 f = idl_global->gen ()->create_valuetype_fwd (&n,
1362 true);
1363 (void) s->fe_add_valuetype_fwd (f);
1364 }
1366 $2->destroy ();
1367 delete $2;
1368 $2 = 0;
1369 }
1370 |
1371 value_decl
1372 {
1373 UTL_Scope *s = idl_global->scopes ().top_non_null ();
1374 UTL_ScopedName n ($1,
1375 0);
1376 AST_ValueTypeFwd *f = 0;
1377 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeForwardSeen);
1379 /*
1380 * Create a node representing a forward declaration of an
1381 * valuetype. Store it in the enclosing scope
1382 */
1383 if (s != 0)
1384 {
1385 f = idl_global->gen ()->create_valuetype_fwd (&n,
1386 false);
1387 (void) s->fe_add_valuetype_fwd (f);
1388 }
1390 $1->destroy ();
1391 delete $1;
1392 $1 = 0;
1394 $$ = 0;
1395 }
1396 ;
1398 value_box_decl
1399 : value_decl type_spec /* in this order %!?*/
1400 {
1401 idl_global->set_parse_state (IDL_GlobalData::PS_ValueBoxDeclSeen);
1403 UTL_Scope *s = idl_global->scopes ().top_non_null ();
1404 UTL_ScopedName n ($1,
1405 0);
1407 if (s != 0 && $2 != 0)
1408 {
1409 /*
1410 * Get the type_spec associated with the valuebox
1411 */
1412 AST_Type *tp = 0;
1413 AST_Typedef *td
1414 = dynamic_cast<AST_Typedef*> ($2);
1416 if (td == 0)
1417 {
1418 tp = dynamic_cast<AST_Type*> ($2);
1419 }
1420 else
1421 {
1422 tp = td->primitive_base_type ();
1423 }
1425 if (tp == 0)
1426 {
1427 // The <type_spec> given is a valid type
1428 idl_global->err ()->not_a_type ($2);
1429 }
1430 else
1431 {
1432 AST_Decl::NodeType nt = tp->node_type ();
1434 if (nt == AST_Decl::NT_valuetype
1435 || nt == AST_Decl::NT_eventtype)
1436 {
1437 // valuetype is not allowed as <type_spec>
1438 // for boxed value
1439 idl_global->err ()->error0 (
1440 UTL_Error::EIDL_ILLEGAL_BOXED_TYPE
1441 );
1442 }
1443 else
1444 {
1445 /*
1446 * Add the valuebox to its definition scope
1447 */
1448 AST_ValueBox *vb =
1449 idl_global->gen ()->create_valuebox (&n,
1450 tp);
1451 (void) s->fe_add_valuebox (vb);
1452 }
1453 }
1454 }
1456 $1->destroy ();
1457 delete $1;
1458 $1 = 0;
1460 $$ = 0;
1461 }
1462 ;
1464 value_elements
1465 : value_elements at_least_one_annotation value_element
1466 {
1467 AST_Annotation_Appls *&annotations = $2;
1468 AST_Decls *&decls = $3;
1469 if (decls)
1470 {
1471 for (size_t i = 0; i < decls->size (); i++)
1472 {
1473 (*decls)[i]->annotation_appls (*annotations);
1474 }
1475 }
1476 else
1477 {
1478 idl_global->err ()-> unsupported_warning (
1479 "Annotating this is not supported");
1480 }
1481 delete annotations;
1482 delete decls;
1483 }
1484 | value_elements value_element
1485 {
1486 delete $2;
1487 }
1488 | %empty
1489 ;
1491 value_element
1492 : state_member
1493 | export
1494 {
1495 AST_Decl *&node = $1;
1496 AST_Decls *value = 0;
1497 if (node)
1498 {
1499 value = new AST_Decls;
1500 value->push_back (node);
1501 }
1502 $$ = value;
1503 }
1504 | init_decl
1505 {
1506 AST_Decl *&node = $1;
1507 AST_Decls *value = 0;
1508 if (node)
1509 {
1510 value = new AST_Decls;
1511 value->push_back (node);
1512 }
1513 $<decls_val>$ = value;
1514 }
1515 ';'
1516 {
1517 $$ = $<decls_val>2;
1518 }
1519 ;
1521 visibility
1522 : IDL_PUBLIC
1523 {
1524 $$ = AST_Field::vis_PUBLIC;
1525 }
1526 | IDL_PRIVATE
1527 {
1528 $$ = AST_Field::vis_PRIVATE;
1529 }
1530 ;
1532 state_member
1533 : visibility member_i
1534 {
1535 AST_Field::Visibility &visibility = $1;
1536 AST_Decls *&decls_ptr = $2;
1537 if (decls_ptr)
1538 {
1539 AST_Decls &decls = *decls_ptr;
1540 for (size_t i = 0; i < decls.size (); i++)
1541 {
1542 AST_Field *field = dynamic_cast<AST_Field *> (decls[i]);
1543 if (field)
1544 {
1545 field->visibility (visibility);
1546 }
1547 }
1548 }
1549 $$ = decls_ptr;
1550 }
1551 ;
1553 exports
1554 : at_least_one_export
1555 | %empty
1556 ;
1558 at_least_one_export
1559 : exports at_least_one_annotation export
1560 {
1561 AST_Annotation_Appls *annotations = $2;
1562 AST_Decl *d = $3;
1563 if (d)
1564 {
1565 d->annotation_appls (*annotations);
1566 }
1567 else
1568 {
1569 idl_global->err ()-> unsupported_warning (
1570 "Annotating this is not supported");
1571 }
1572 delete annotations;
1573 }
1574 | exports export
1575 ;
1577 export
1578 : type_dcl
1579 {
1580 idl_global->set_parse_state (IDL_GlobalData::PS_TypeDeclSeen);
1581 }
1582 ';'
1583 {
1584 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
1585 }
1586 | typeid_dcl
1587 {
1588 idl_global->set_parse_state (IDL_GlobalData::PS_TypeIdDeclSeen);
1589 }
1590 ';'
1591 {
1592 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
1593 }
1594 | typeprefix_dcl
1595 {
1596 idl_global->set_parse_state (IDL_GlobalData::PS_TypePrefixDeclSeen);
1597 }
1598 ';'
1599 {
1600 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
1601 }
1602 | const_dcl
1603 {
1604 idl_global->set_parse_state (IDL_GlobalData::PS_ConstDeclSeen);
1605 }
1606 ';'
1607 {
1608 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
1609 }
1610 | exception
1611 {
1612 idl_global->set_parse_state (IDL_GlobalData::PS_ExceptDeclSeen);
1613 }
1614 ';'
1615 {
1616 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
1617 }
1618 | attribute
1619 {
1620 idl_global->set_parse_state (IDL_GlobalData::PS_AttrDeclSeen);
1621 }
1622 ';'
1623 {
1624 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
1625 }
1626 | operation
1627 {
1628 idl_global->set_parse_state (IDL_GlobalData::PS_OpDeclSeen);
1629 }
1630 ';'
1631 {
1632 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
1633 }
1634 | error
1635 {
1636 idl_global->err ()->syntax_error (idl_global->parse_state ());
1637 }
1638 ';'
1639 {
1640 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
1641 yyerrok;
1642 $$ = 0;
1643 }
1644 ;
1646 at_least_one_scoped_name :
1647 scoped_name scoped_names
1648 {
1649 ACE_NEW_RETURN ($<nlval>$,
1650 UTL_NameList ($1,
1651 $2),
1652 1);
1653 }
1654 ;
1656 scoped_names
1657 : scoped_names
1658 ','
1659 {
1660 idl_global->set_parse_state (IDL_GlobalData::PS_SNListCommaSeen);
1661 }
1662 scoped_name
1663 {
1664 idl_global->set_parse_state (IDL_GlobalData::PS_ScopedNameSeen);
1666 UTL_NameList *nl = 0;
1667 ACE_NEW_RETURN (nl,
1668 UTL_NameList ($4,
1669 0),
1670 1);
1672 if ($1 == 0)
1673 {
1674 $<nlval>$ = nl;
1675 }
1676 else
1677 {
1678 $1->nconc (nl);
1679 $<nlval>$ = $1;
1680 }
1681 }
1682 | %empty
1683 {
1684 $<nlval>$ = 0;
1685 }
1686 ;
1688 scoped_name
1689 : id
1690 {
1691 idl_global->set_parse_state (IDL_GlobalData::PS_SN_IDSeen);
1693 ACE_NEW_RETURN ($$,
1694 UTL_IdList ($1,
1695 0),
1696 1);
1697 }
1698 | IDL_SCOPE_DELIMITOR
1699 {
1700 idl_global->set_parse_state (IDL_GlobalData::PS_ScopeDelimSeen);
1701 }
1702 id
1703 {
1704 idl_global->set_parse_state (IDL_GlobalData::PS_SN_IDSeen);
1706 Identifier *id = 0;
1707 ACE_NEW_RETURN (id,
1708 Identifier ($1),
1709 1);
1710 ACE::strdelete ($1);
1711 $1 = 0;
1712 UTL_IdList *sn = 0;
1713 ACE_NEW_RETURN (sn,
1714 UTL_IdList ($3,
1715 0),
1716 1);
1717 ACE_NEW_RETURN ($<idlist>$,
1718 UTL_IdList (id,
1719 sn),
1720 1);
1721 }
1722 | scoped_name
1723 IDL_SCOPE_DELIMITOR
1724 {
1725 idl_global->set_parse_state (IDL_GlobalData::PS_ScopeDelimSeen);
1727 // This cleans up all the non-global "::"s in scoped names.
1728 // If there is a global one, it gets put into the UTL_IdList,
1729 // so we clean it up in the case above.
1730 ACE::strdelete ($2);
1731 $2 = 0;
1732 }
1733 id
1734 {
1735 idl_global->set_parse_state (IDL_GlobalData::PS_SN_IDSeen);
1737 UTL_IdList *sn = 0;
1738 ACE_NEW_RETURN (sn,
1739 UTL_IdList ($4,
1740 0),
1741 1);
1742 $1->nconc (sn);
1743 $<idlist>$ = $1;
1744 }
1745 ;
1747 id : IDENTIFIER
1748 {
1749 ACE_NEW_RETURN ($$,
1750 Identifier ($1),
1751 1);
1752 ACE::strdelete ($1);
1753 $1 = 0;
1754 }
1755 ;
1757 defining_id : IDENTIFIER
1758 {
1759 /* defining_id is a defining identifier
1760 whereas id is usually a reference to a defining identifier */
1761 ACE_NEW_RETURN ($$, Identifier ($1), 1);
1762 ACE::strdelete ($1);
1763 $1 = 0;
1764 }
1765 ;
1767 interface_forward :
1768 interface_decl
1769 {
1770 UTL_Scope *s = idl_global->scopes ().top_non_null ();
1771 UTL_ScopedName n ($1, 0);
1773 if (ACE_OS::strcmp ($1->get_string (),
1774 "TypeCode") == 0
1775 && !idl_global->in_main_file ())
1776 {
1777 AST_PredefinedType *pdt =
1778 idl_global->gen ()->create_predefined_type (
1779 AST_PredefinedType::PT_pseudo,
1780 &n
1781 );
1783 s->add_to_scope (pdt);
1785 $1->destroy ();
1786 delete $1;
1787 $1 = 0;
1789 break;
1790 }
1792 AST_InterfaceFwd *f = 0;
1793 idl_global->set_parse_state (IDL_GlobalData::PS_InterfaceForwardSeen);
1795 /*
1796 * Create a node representing a forward declaration of an
1797 * interface. Store it in the enclosing scope
1798 */
1799 if (s != 0)
1800 {
1801 f = idl_global->gen ()->create_interface_fwd (&n,
1802 0,
1803 0);
1804 (void) s->fe_add_interface_fwd (f);
1805 }
1807 $1->destroy ();
1808 delete $1;
1809 $1 = 0;
1810 }
1811 |
1812 IDL_LOCAL interface_decl
1813 {
1814 UTL_Scope *s = idl_global->scopes ().top_non_null ();
1815 UTL_ScopedName n ($2,
1816 0);
1817 AST_InterfaceFwd *f = 0;
1818 idl_global->set_parse_state (
1819 IDL_GlobalData::PS_InterfaceForwardSeen
1820 );
1822 /*
1823 * Create a node representing a forward declaration of an
1824 * interface. Store it in the enclosing scope
1825 */
1826 if (s != 0)
1827 {
1828 f = idl_global->gen ()->create_interface_fwd (&n,
1829 1,
1830 0);
1831 (void) s->fe_add_interface_fwd (f);
1832 }
1834 $2->destroy ();
1835 delete $2;
1836 $2 = 0;
1837 }
1838 |
1839 IDL_ABSTRACT interface_decl
1840 {
1841 UTL_Scope *s = idl_global->scopes ().top_non_null ();
1842 UTL_ScopedName n ($2,
1843 0);
1844 AST_InterfaceFwd *f = 0;
1845 idl_global->set_parse_state (
1846 IDL_GlobalData::PS_InterfaceForwardSeen
1847 );
1849 /*
1850 * Create a node representing a forward declaration of an
1851 * interface. Store it in the enclosing scope
1852 */
1853 if (s != 0)
1854 {
1855 f = idl_global->gen ()->create_interface_fwd (&n,
1856 0,
1857 1);
1858 (void) s->fe_add_interface_fwd (f);
1859 }
1861 $2->destroy ();
1862 delete $2;
1863 $2 = 0;
1865 $$ = dynamic_cast<AST_Decl *> (f);
1866 }
1867 ;
1869 const_dcl :
1870 IDL_CONST
1871 {
1872 idl_global->set_parse_state (IDL_GlobalData::PS_ConstSeen);
1873 }
1874 const_type
1875 {
1876 idl_global->set_parse_state (IDL_GlobalData::PS_ConstTypeSeen);
1877 }
1878 defining_id
1879 {
1880 idl_global->set_parse_state (IDL_GlobalData::PS_ConstIDSeen);
1881 }
1882 '='
1883 {
1884 idl_global->set_parse_state (IDL_GlobalData::PS_ConstAssignSeen);
1885 }
1886 expression
1887 {
1888 $$ = 0;
1889 UTL_ScopedName n ($5, 0);
1891 UTL_Scope *s = idl_global->scopes ().top_non_null ();
1892 AST_Constant *c = 0;
1893 idl_global->set_parse_state (IDL_GlobalData::PS_ConstExprSeen);
1895 /*
1896 * Create a node representing a constant declaration. Store
1897 * it in the enclosing scope.
1898 */
1899 if ($9 != 0 && s != 0)
1900 {
1901 AST_Param_Holder *param_holder = $9->param_holder ();
1903 AST_Expression::AST_ExprValue *result =
1904 $9->check_and_coerce ($3, tao_enum_constant_decl);
1905 tao_enum_constant_decl = 0;
1907 // If the expression is a template parameter place
1908 // holder, 'result' will be 0, but it's ok.
1909 if (result == 0 && param_holder == 0)
1910 {
1911 idl_global->err ()->coercion_error ($9, $3);
1912 $9->destroy ();
1913 delete $9;
1914 $9 = 0;
1915 }
1916 else
1917 {
1918 AST_Expression::ExprType et = $3;
1920 if (param_holder != 0
1921 && et != param_holder->info ()->const_type_)
1922 {
1923 idl_global->err ()->mismatched_template_param (
1924 param_holder->info ()->name_.c_str ());
1925 }
1926 else
1927 {
1928 c = idl_global->gen ()->create_constant ($3, $9, &n);
1929 (void) s->fe_add_constant (c);
1930 $$ = c;
1931 }
1932 }
1934 delete result;
1935 result = 0;
1936 }
1938 $5->destroy ();
1939 delete $5;
1940 $5 = 0;
1941 }
1942 ;
1944 const_type
1945 : integer_type
1946 | char_type
1947 | octet_type
1948 | boolean_type
1949 | floating_pt_type
1950 | fixed_type
1951 | string_type_spec
1952 {
1953 $$ = AST_Expression::EV_string;
1954 }
1955 | wstring_type_spec
1956 {
1957 $$ = AST_Expression::EV_wstring;
1958 }
1959 | scoped_name
1960 {
1961 UTL_Scope *s = idl_global->scopes ().top_non_null ();
1962 AST_PredefinedType *c = 0;
1963 AST_Typedef *t = 0;
1964 UTL_ScopedName *sn = $1;
1966 /*
1967 * If the constant's type is a scoped name, it must resolve
1968 * to a scalar constant type
1969 */
1970 AST_Decl *d =
1971 s->lookup_by_name (sn);
1973 if (s != 0 && d != 0)
1974 {
1975 /*
1976 * Look through typedefs.
1977 */
1978 while (d->node_type () == AST_Decl::NT_typedef)
1979 {
1980 t = dynamic_cast<AST_Typedef*> (d);
1982 if (t == 0)
1983 {
1984 break;
1985 }
1987 d = t->base_type ();
1988 }
1990 if (d->node_type () == AST_Decl::NT_pre_defined)
1991 {
1992 c = dynamic_cast<AST_PredefinedType*> (d);
1994 $$ = FE_Utils::PredefinedTypeToExprType (c->pt ());
1995 }
1996 else if (d->node_type () == AST_Decl::NT_string)
1997 {
1998 $$ = AST_Expression::EV_string;
1999 }
2000 else if (d->node_type () == AST_Decl::NT_wstring)
2001 {
2002 $$ = AST_Expression::EV_wstring;
2003 }
2004 else if (d->node_type () == AST_Decl::NT_enum)
2005 {
2006 $$ = AST_Expression::EV_enum;
2007 tao_enum_constant_decl =
2008 dynamic_cast<AST_Enum*> (d);
2009 }
2010 else
2011 {
2012 idl_global->err ()->constant_expected (sn, d);
2013 }
2014 }
2015 else
2016 {
2017 idl_global->err ()->lookup_error (sn);
2018 }
2020 sn->destroy ();
2021 delete sn;
2022 sn = 0;
2023 $1 = 0;
2024 }
2025 ;
2027 expression : const_expr ;
2029 const_expr : or_expr ;
2031 or_expr : xor_expr
2032 | or_expr '|' xor_expr
2033 {
2034 $$ =
2035 idl_global->gen ()->create_expr (
2036 AST_Expression::EC_or,
2037 $1,
2038 $3
2039 );
2040 }
2041 ;
2043 xor_expr
2044 : and_expr
2045 | xor_expr '^' and_expr
2046 {
2047 $$ =
2048 idl_global->gen ()->create_expr (
2049 AST_Expression::EC_xor,
2050 $1,
2051 $3
2052 );
2053 }
2054 ;
2056 and_expr
2057 : shift_expr
2058 | and_expr '&' shift_expr
2059 {
2060 $$ =
2061 idl_global->gen ()->create_expr (
2062 AST_Expression::EC_and,
2063 $1,
2064 $3
2065 );
2066 }
2067 ;
2069 shift_expr
2070 : add_expr
2071 | shift_expr IDL_LEFT_SHIFT add_expr
2072 {
2073 $$ =
2074 idl_global->gen ()->create_expr (
2075 AST_Expression::EC_left,
2076 $1,
2077 $3
2078 );
2079 }
2080 | shift_expr IDL_RIGHT_SHIFT add_expr
2081 {
2082 $$ =
2083 idl_global->gen ()->create_expr (
2084 AST_Expression::EC_right,
2085 $1,
2086 $3
2087 );
2088 }
2089 ;
2091 add_expr
2092 : mult_expr
2093 | add_expr '+' mult_expr
2094 {
2095 $$ =
2096 idl_global->gen ()->create_expr (
2097 AST_Expression::EC_add,
2098 $1,
2099 $3
2100 );
2101 }
2102 | add_expr '-' mult_expr
2103 {
2104 $$ =
2105 idl_global->gen ()->create_expr (
2106 AST_Expression::EC_minus,
2107 $1,
2108 $3
2109 );
2110 }
2111 ;
2113 mult_expr
2114 : unary_expr
2115 | mult_expr '*' unary_expr
2116 {
2117 $$ =
2118 idl_global->gen ()->create_expr (
2119 AST_Expression::EC_mul,
2120 $1,
2121 $3
2122 );
2123 }
2124 | mult_expr '/' unary_expr
2125 {
2126 $$ =
2127 idl_global->gen ()->create_expr (
2128 AST_Expression::EC_div,
2129 $1,
2130 $3
2131 );
2132 }
2133 | mult_expr '%' unary_expr
2134 {
2135 $$ =
2136 idl_global->gen ()->create_expr (
2137 AST_Expression::EC_mod,
2138 $1,
2139 $3
2140 );
2141 }
2142 ;
2144 unary_expr
2145 : primary_expr
2146 | '+' primary_expr
2147 {
2148 $$ =
2149 idl_global->gen ()->create_expr (
2150 AST_Expression::EC_u_plus,
2151 $2,
2152 0
2153 );
2154 }
2155 | '-' primary_expr
2156 {
2157 $$ =
2158 idl_global->gen ()->create_expr (
2159 AST_Expression::EC_u_minus,
2160 $2,
2161 0
2162 );
2163 }
2164 | '~' primary_expr
2165 {
2166 $$ =
2167 idl_global->gen ()->create_expr (
2168 AST_Expression::EC_bit_neg,
2169 $2,
2170 0
2171 );
2172 }
2173 ;
2175 primary_expr
2176 : scoped_name
2177 {
2178 UTL_ScopedName *name = $1;
2180 /*
2181 * An expression which is a scoped name is not resolved now,
2182 * but only when it is evaluated (such as when it is assigned
2183 * as a constant value).
2184 */
2185 AST_Expression *expr = 0;
2187 AST_Decl *node = stack_based_lookup_for_primary_expr ?
2188 idl_global->scopes ().lookup_by_name (name) :
2189 idl_global->scopes ().top_non_null ()->lookup_by_name (name);
2190 if (!node)
2191 {
2192 if (!idl_global->ignore_lookup_errors_)
2193 {
2194 idl_global->err ()->lookup_error (name);
2195 return 1;
2196 }
2197 }
2198 else if (node->node_type () == AST_Decl::NT_const)
2199 {
2200 /*
2201 * If the scoped name is an IDL constant, it
2202 * may be used in an array dim, a string
2203 * bound, or a sequence bound. If so, it
2204 * must be unsigned and > 0. We assign the
2205 * constant's value and type to the
2206 * expression created here so we can check
2207 * them later.
2208 */
2209 AST_Constant *c = dynamic_cast<AST_Constant *> (node);
2210 expr = idl_global->gen ()->create_expr (
2211 c->constant_value (),
2212 c->et ());
2213 }
2214 else
2215 {
2216 // An AST_Expression owns the scoped name
2217 // passed in this constructor, so we copy it
2218 // and destroy it below no matter which case
2219 // is followed.
2220 expr = idl_global->gen ()->create_expr (name->copy ());
2221 if (node->node_type () == AST_Decl::NT_enum_val)
2222 {
2223 expr->enum_parent (
2224 dynamic_cast<AST_EnumVal *> (node)->enum_parent ());
2225 }
2226 }
2228 $<exval>$ = expr;
2229 name->destroy ();
2230 delete name;
2231 $1 = name = 0;
2232 }
2233 | literal
2234 | '(' const_expr ')'
2235 {
2236 $$ = $2;
2237 }
2238 ;
2240 literal
2241 : IDL_INTEGER_LITERAL
2242 {
2243 $$ = idl_global->gen ()->create_expr ($1);
2244 }
2245 | IDL_UINTEGER_LITERAL
2246 {
2247 $$ =
2248 idl_global->gen ()->create_expr ($1);
2249 }
2250 | IDL_STRING_LITERAL
2251 {
2252 $$ = idl_global->gen ()->create_expr ($1);
2253 $1->destroy ();
2254 delete $1;
2255 $1 = 0;
2256 }
2257 | IDL_WSTRING_LITERAL
2258 {
2259 char *wide_string = $1;
2260 $$ = idl_global->gen ()->create_expr (wide_string);
2261 ACE_OS::free (wide_string);
2262 $1 = 0;
2263 }
2264 | IDL_CHARACTER_LITERAL
2265 {
2266 $$ = idl_global->gen ()->create_expr ($1);
2267 }
2268 | IDL_WCHAR_LITERAL
2269 {
2270 ACE_OutputCDR::from_wchar wc ($1);
2271 $$ = idl_global->gen ()->create_expr (wc);
2272 }
2273 | IDL_FIXED_PT_LITERAL
2274 {
2275 $$ = idl_global->gen ()->create_expr ($1);
2276 }
2277 | IDL_FLOATING_PT_LITERAL
2278 {
2279 $$ = idl_global->gen ()->create_expr ($1);
2280 }
2281 | IDL_TRUETOK
2282 {
2283 $$ = idl_global->gen ()->create_expr (true);
2284 }
2285 | IDL_FALSETOK
2286 {
2287 $$ = idl_global->gen ()->create_expr (false);
2288 }
2289 ;
2291 positive_int_expr :
2292 const_expr
2293 {
2294 int good_expression = 1;
2295 $1->evaluate (AST_Expression::EK_positive_int);
2296 AST_Expression::AST_ExprValue *ev = $1->ev ();
2298 /*
2299 * If const_expr is an enum value (AST_EnumVal inherits from
2300 * AST_Constant), the AST_ExprValue will probably not be set,
2301 * but there's no need to check anyway
2302 */
2303 if (ev != 0)
2304 {
2305 switch (ev->et)
2306 {
2307 case AST_Expression::EV_ushort:
2308 if (ev->u.usval == 0)
2309 {
2310 good_expression = 0;
2311 }
2313 break;
2314 case AST_Expression::EV_ulong:
2315 if (ev->u.ulval == 0)
2316 {
2317 good_expression = 0;
2318 }
2320 break;
2321 case AST_Expression::EV_ulonglong:
2322 if (ev->u.ullval == 0)
2323 {
2324 good_expression = 0;
2325 }
2327 break;
2328 case AST_Expression::EV_octet:
2329 if (ev->u.oval == 0)
2330 {
2331 good_expression = 0;
2332 }
2334 break;
2335 case AST_Expression::EV_bool:
2336 if (ev->u.bval == 0)
2337 {
2338 good_expression = 0;
2339 }
2341 break;
2342 default:
2343 good_expression = 0;
2344 break;
2345 }
2346 }
2348 if (good_expression)
2349 {
2350 $$ = $1;
2351 }
2352 else
2353 {
2354 idl_global->err ()->syntax_error (idl_global->parse_state ());
2355 }
2356 }
2357 ;
2359 annotation_dcl
2360 : IDL_ANNOTATION_DECL defining_id '{'
2361 {
2362 if (idl_global->idl_version_ < IDL_VERSION_4)
2363 {
2364 idl_global->err ()->idl_version_error (
2365 "Annotations are an IDL4 feature");
2366 }
2368 Identifier *id = $2;
2369 UTL_ScopedName name (id, 0);
2370 AST_Annotation_Decl::escape_name (&name);
2371 AST_Annotation_Decl *annotation_decl = idl_global->gen ()->
2372 create_annotation_decl (&name);
2373 idl_global->scopes ().top_non_null ()->
2374 fe_add_annotation_decl (annotation_decl);
2375 idl_global->scopes ().push (annotation_decl);
2376 }
2377 annotation_body '}'
2378 {
2379 Identifier *id = $2;
2380 idl_global->scopes ().pop ();
2381 id->destroy ();
2382 delete id;
2384 $$ = 0;
2385 }
2386 ;
2388 annotation_body
2389 : annotation_body annotation_statement
2390 | %empty
2391 ;
2393 annotation_statement
2394 : annotation_member
2395 | const_dcl ';'
2396 | enum_type ';'
2397 | IDL_TYPEDEF
2398 {
2399 idl_global->set_parse_state (IDL_GlobalData::PS_TypedefSeen);
2400 idl_global->in_typedef (true);
2401 }
2402 type_declarator ';'
2403 ;
2405 annotation_member_type
2406 : const_type
2407 | any_type
2408 ;
2410 annotation_member
2411 : annotation_member_type defining_id annotation_member_default ';'
2412 {
2413 UTL_Scope *scope = idl_global->scopes ().top_non_null ();
2414 UTL_Scope *root = idl_global->scopes ().bottom ();
2416 AST_Expression::ExprType type = $1;
2417 Identifier *name = $2;
2418 // Annotation member names can't clash with C++ keywords
2419 FE_Utils::original_local_name (name);
2420 UTL_ScopedName *scoped_name = new UTL_ScopedName (name, 0);
2421 AST_Expression *default_value = $3;
2423 AST_Decl * type_obj;
2424 switch (type)
2425 {
2426 case AST_Expression::EV_string:
2427 case AST_Expression::EV_wstring:
2428 type_obj = tao_string_decl;
2429 break;
2430 case AST_Expression::EV_enum:
2431 type_obj = tao_enum_constant_decl;
2432 break;
2433 default:
2434 type_obj = root->lookup_primitive_type (type);
2435 }
2437 FE_Declarator *declarator = new FE_Declarator (
2438 scoped_name, FE_Declarator::FD_simple, 0);
2439 AST_Annotation_Member *member = idl_global->gen ()->
2440 create_annotation_member (
2441 type, declarator->compose (type_obj), declarator->name ());
2442 scope->fe_add_annotation_member (member);
2444 declarator->destroy ();
2445 delete declarator;
2447 if (default_value)
2448 {
2449 // Check if types are compatible, else report error
2450 AST_Expression::AST_ExprValue *result =
2451 default_value->check_and_coerce (type, tao_enum_constant_decl);
2452 tao_enum_constant_decl = 0;
2453 if (result)
2454 {
2455 member->value (default_value);
2456 }
2457 else
2458 {
2459 idl_global->err ()->coercion_error (default_value, type);
2460 }
2461 delete result;
2462 }
2463 }
2464 ;
2466 annotation_member_default
2467 : IDL_DEFAULT const_expr
2468 {
2469 $$ = $2;
2470 }
2471 | %empty
2472 {
2473 $$ = 0;
2474 }
2475 ;
2477 at_least_one_annotation
2478 : annotations_maybe annotation_appl
2479 {
2480 AST_Annotation_Appls *annotations = $1;
2481 AST_Annotation_Appl *annotation = $2;
2482 if (annotation)
2483 {
2484 annotations->add (annotation);
2485 }
2486 $$ = annotations;
2487 }
2488 ;
2490 annotations_maybe
2491 : annotations_maybe annotation_appl
2492 {
2493 AST_Annotation_Appls *annotations = $1;
2494 AST_Annotation_Appl *annotation = $2;
2495 if (annotation)
2496 {
2497 annotations->add (annotation);
2498 }
2499 $$ = annotations;
2500 }
2501 | %empty
2502 {
2503 $$ = new AST_Annotation_Appls ();
2504 }
2505 ;
2507 annotation_appl
2508 : IDL_ANNOTATION_SYMBOL scoped_name
2509 {
2510 if (idl_global->idl_version_ < IDL_VERSION_4)
2511 {
2512 idl_global->err ()->idl_version_error (
2513 "Annotations are an IDL4 feature");
2514 }
2516 AST_Annotation_Decl *decl = 0;
2517 UTL_ScopedName *name = $2;
2518 AST_Annotation_Decl::escape_name (name);
2520 // Check for Matching Annotation Declaration
2521 AST_Decl *d = idl_global->scopes ().top_non_null ()->
2522 lookup_by_name (name);
2523 if (d)
2524 {
2525 decl = dynamic_cast<AST_Annotation_Decl*> (d);
2526 if (decl)
2527 {
2528 idl_global->scopes ().push (decl);
2529 }
2530 }
2531 else
2532 {
2533 Identifier &id = *name->last_component ();
2534 switch (idl_global->unknown_annotations_)
2535 {
2536 default:
2537 case IDL_GlobalData::UNKNOWN_ANNOTATIONS_WARN_ONCE:
2538 if (idl_global->unknown_annotations_seen_.insert (id) == 1)
2539 {
2540 break;
2541 }
2542 idl_global->err ()->lookup_warning (name);
2543 break;
2544 case IDL_GlobalData::UNKNOWN_ANNOTATIONS_WARN_ALL:
2545 idl_global->err ()->lookup_warning (name);
2546 break;
2547 case IDL_GlobalData::UNKNOWN_ANNOTATIONS_ERROR:
2548 idl_global->err ()->lookup_error (name);
2549 break;
2550 case IDL_GlobalData::UNKNOWN_ANNOTATIONS_IGNORE:
2551 break;
2552 }
2554 /*
2555 * Ignore lookup errors for parameter values that might depend on
2556 * constants or enums from the missing annotation declaration.
2557 */
2558 idl_global->ignore_lookup_errors_ = true;
2559 }
2561 stack_based_lookup_for_primary_expr = true;
2563 $<annotation_decl_val>$ = decl;
2564 }
2565 annotation_appl_params_maybe
2566 {
2567 idl_global->ignore_lookup_errors_ = false;
2568 stack_based_lookup_for_primary_expr = false;
2569 AST_Annotation_Appl *appl = 0;
2570 UTL_ScopedName *name = $2;
2571 AST_Annotation_Decl *decl = $<annotation_decl_val>3;
2572 AST_Annotation_Appl::Params *params = $4;
2574 if (decl)
2575 {
2576 appl = idl_global->gen ()->create_annotation_appl (name, params);
2577 appl->apply_from (decl);
2578 idl_global->scopes ().pop ();
2579 }
2580 else
2581 {
2582 AST_Annotation_Appl::delete_params (params);
2583 }
2585 if (name)
2586 {
2587 name->destroy ();
2588 delete name;
2589 }
2591 $$ = appl;
2592 }
2593 ;
2595 annotation_appl_params_maybe
2596 : '(' annotation_appl_params ')'
2597 {
2598 $$ = $2;
2599 }
2600 | %empty
2601 {
2602 $$ = 0;
2603 }
2604 ;
2606 annotation_appl_params
2607 : const_expr
2608 {
2609 AST_Annotation_Appl::Params *params = new AST_Annotation_Appl::Params;
2610 AST_Annotation_Appl::Param *param = new AST_Annotation_Appl::Param;
2611 param->id = 0;
2612 param->expr = $1;
2613 params->push (param);
2614 $$ = params;
2615 }
2616 | named_annotation_appl_params
2617 {
2618 $$ = $1;
2619 }
2620 ;
2622 named_annotation_appl_params
2623 : named_annotation_appl_param more_named_annotation_appl_params
2624 {
2625 AST_Annotation_Appl::Params *params = $2;
2626 params->push ($1);
2627 $$ = params;
2628 }
2630 more_named_annotation_appl_params
2631 : ',' named_annotation_appl_param more_named_annotation_appl_params
2632 {
2633 AST_Annotation_Appl::Params *params = $3;
2634 params->push ($2);
2635 $$ = params;
2636 }
2637 | %empty
2638 {
2639 $$ = new AST_Annotation_Appl::Params;
2640 }
2641 ;
2643 named_annotation_appl_param
2644 : id '=' const_expr
2645 {
2646 AST_Annotation_Appl::Param *param = new AST_Annotation_Appl::Param;
2647 param->id = $1;
2648 // Annotation Member Names Can't Clash with C++ keywords
2649 FE_Utils::original_local_name (param->id);
2650 param->expr = $3;
2651 $$ = param;
2652 }
2653 ;
2655 type_dcl
2656 : IDL_TYPEDEF
2657 {
2658 idl_global->set_parse_state (IDL_GlobalData::PS_TypedefSeen);
2659 idl_global->in_typedef (true);
2660 }
2661 type_declarator
2662 {
2663 $$ = $3;
2664 }
2665 | struct_type
2666 {
2667 $$ = $1;
2668 }
2669 | union_type
2670 {
2671 $$ = $1;
2672 }
2673 | enum_type
2674 {
2675 $$ = $1;
2676 }
2677 | IDL_NATIVE simple_declarator
2678 {
2679 UTL_Scope *s = idl_global->scopes ().top_non_null ();
2680 AST_Native *node = 0;
2681 idl_global->set_parse_state (IDL_GlobalData::PS_NativeSeen);
2683 /*
2684 * Create a node representing a Native and add it to its
2685 * enclosing scope
2686 */
2687 if (s != 0)
2688 {
2689 node =
2690 idl_global->gen ()->create_native (
2691 $2->name ()
2692 );
2693 /*
2694 * Add it to its defining scope
2695 */
2696 (void) s->fe_add_native (node);
2697 }
2699 $2->destroy ();
2700 delete $2;
2701 $2 = 0;
2703 $$ = 0;
2704 }
2705 | constructed_forward_type_spec
2706 {
2707 $$ = 0;
2708 }
2709 ;
2711 type_declarator :
2712 type_spec
2713 {
2714 idl_global->set_parse_state (IDL_GlobalData::PS_TypeSpecSeen);
2715 }
2716 at_least_one_declarator
2717 {
2718 AST_Decl *type_spec = $1;
2719 UTL_DeclList *decls = $3;
2721 UTL_Scope *s = idl_global->scopes ().top_non_null ();
2722 FE_Declarator *d = 0;
2723 AST_Typedef *t = 0;
2724 unsigned long index = 0UL;
2725 idl_global->set_parse_state (IDL_GlobalData::PS_DeclaratorsSeen);
2727 /*
2728 * Create a list of type renamings. Add them to the
2729 * enclosing scope
2730 */
2731 if (s && type_spec && decls)
2732 {
2733 for (UTL_DecllistActiveIterator l (decls); !l.is_done (); l.next ())
2734 {
2735 d = l.item ();
2736 if (d == 0)
2737 {
2738 continue;
2739 }
2741 AST_Type *tp = d->compose (type_spec);
2742 if (tp == 0)
2743 {
2744 continue;
2745 }
2747 if (AST_Decl::NT_except == tp->node_type ())
2748 {
2749 idl_global->err ()->not_a_type (tp);
2750 continue;
2751 }
2753 t = idl_global->gen ()->create_typedef (tp,
2754 d->name (),
2755 s->is_local (),
2756 s->is_abstract ());
2758 // If the base type is a sequence or array, the typedef
2759 // constructor sets owns_base_type_ to true. But if
2760 // there is a comma-separated list of such typedefs,
2761 // the base type can be destroyed only once. In all
2762 // other cases, the line below has no effect.
2763 if (index++ > 0)
2764 {
2765 t->owns_base_type (false);
2766 }
2768 (void) s->fe_add_typedef (t);
2769 idl_global->in_typedef (false);
2770 }
2772 // This FE_Declarator class isn't destroyed with the AST.
2773 decls->destroy ();
2774 delete decls;
2775 $3 = decls = 0;
2776 }
2778 $$ = t;
2779 }
2780 ;
2782 type_spec
2783 : simple_type_spec
2784 | constructed_type_spec
2785 ;
2787 simple_type_spec
2788 : base_type_spec
2789 {
2790 $$ =
2791 idl_global->scopes ().bottom ()->lookup_primitive_type (
2792 $1
2793 );
2794 }
2795 | template_type_spec
2796 | scoped_name
2797 {
2798 UTL_Scope *s = idl_global->scopes ().top_non_null ();
2799 AST_Decl *d = 0;
2801 if (s != 0)
2802 {
2803 d =
2804 s->lookup_by_name ($1);
2805 }
2807 if (d == 0)
2808 {
2809 idl_global->err ()->lookup_error ($1);
2810 }
2811 else
2812 {
2813 d->last_referenced_as ($1);
2814 }
2817 $$ = d;
2818 }
2819 ;
2821 base_type_spec
2822 : integer_type
2823 | floating_pt_type
2824 | char_type
2825 | boolean_type
2826 | octet_type
2827 | fixed_type
2828 | any_type
2829 | object_type
2830 ;
2832 template_type_spec
2833 : sequence_type_spec
2834 | string_type_spec
2835 | wstring_type_spec
2836 | fixed_type_spec
2837 ;
2839 constructed_type_spec
2840 : struct_type
2841 | union_type
2842 | enum_type
2843 ;
2845 constructed_forward_type_spec
2846 : struct_forward_type
2847 | union_forward_type
2848 ;
2850 at_least_one_declarator :
2851 declarator declarators
2852 {
2853 ACE_NEW_RETURN ($$,
2854 UTL_DeclList ($1,
2855 $2),
2856 1);
2857 }
2858 ;
2860 declarators
2861 : declarators
2862 ','
2863 {
2864 idl_global->set_parse_state (IDL_GlobalData::PS_DeclsCommaSeen);
2865 }
2866 declarator
2867 {
2868 idl_global->set_parse_state (IDL_GlobalData::PS_DeclsDeclSeen);
2870 UTL_DeclList *dl = 0;
2871 ACE_NEW_RETURN (dl,
2872 UTL_DeclList ($4,
2873 0),
2874 1);
2876 if ($1 == 0)
2877 {
2878 $<dlval>$ = dl;
2879 }
2880 else
2881 {
2882 $1->nconc (dl);
2883 $<dlval>$ = $1;
2884 }
2885 }
2886 | %empty
2887 {
2888 $<dlval>$ = 0;
2889 }
2890 ;
2892 declarator
2893 : simple_declarator
2894 | complex_declarator
2895 ;
2897 at_least_one_simple_declarator :
2898 simple_declarator simple_declarators
2899 {
2900 ACE_NEW_RETURN ($<dlval>$,
2901 UTL_DeclList ($1,
2902 $2),
2903 1);
2904 }
2905 ;
2907 simple_declarators
2908 : simple_declarators
2909 ','
2910 {
2911 idl_global->set_parse_state (IDL_GlobalData::PS_DeclsCommaSeen);
2912 }
2913 simple_declarator
2914 {
2915 idl_global->set_parse_state (IDL_GlobalData::PS_DeclsDeclSeen);
2917 UTL_DeclList *dl = 0;
2918 ACE_NEW_RETURN (dl,
2919 UTL_DeclList ($4,
2920 0),
2921 1);
2923 if ($1 == 0)
2924 {
2925 $<dlval>$ = dl;
2926 }
2927 else
2928 {
2929 $1->nconc (dl);
2930 $<dlval>$ = $1;
2931 }
2932 }
2933 | %empty
2934 {
2935 $<dlval>$ = 0;
2936 }
2937 ;
2939 simple_declarator :
2940 defining_id
2941 {
2942 UTL_ScopedName *sn = 0;
2943 ACE_NEW_RETURN (sn,
2944 UTL_ScopedName ($1,
2945 0),
2946 1);
2947 ACE_NEW_RETURN ($<deval>$,
2948 FE_Declarator (sn,
2949 FE_Declarator::FD_simple,
2950 0),
2951 1);
2952 }
2953 ;
2955 complex_declarator :
2956 array_declarator
2957 {
2958 UTL_ScopedName *sn = 0;
2959 ACE_NEW_RETURN (sn,
2960 UTL_ScopedName (
2961 $1->local_name ()->copy (),
2962 0
2963 ),
2964 1);
2965 ACE_NEW_RETURN ($<deval>$,
2966 FE_Declarator (sn,
2967 FE_Declarator::FD_complex,
2968 $1),
2969 1);
2970 }
2971 ;
2973 integer_type
2974 : signed_int
2975 | unsigned_int
2976 ;
2978 signed_int
2979 : IDL_LONG
2980 {
2981 $$ = AST_Expression::EV_long;
2982 }
2983 | IDL_LONG IDL_LONG
2984 {
2985 $$ = AST_Expression::EV_longlong;
2986 }
2987 | IDL_SHORT
2988 {
2989 $$ = AST_Expression::EV_short;
2990 }
2991 | IDL_INT8
2992 {
2993 $$ = AST_Expression::EV_int8;
2994 }
2995 | IDL_INT16
2996 {
2997 $$ = AST_Expression::EV_short;
2998 }
2999 | IDL_INT32
3000 {
3001 $$ = AST_Expression::EV_long;
3002 }
3003 | IDL_INT64
3004 {
3005 $$ = AST_Expression::EV_longlong;
3006 }
3007 ;
3009 unsigned_int
3010 : IDL_UNSIGNED IDL_LONG
3011 {
3012 $$ = AST_Expression::EV_ulong;
3013 }
3014 | IDL_UNSIGNED IDL_LONG IDL_LONG
3015 {
3016 $$ = AST_Expression::EV_ulonglong;
3017 }
3018 | IDL_UNSIGNED IDL_SHORT
3019 {
3020 $$ = AST_Expression::EV_ushort;
3021 }
3022 | IDL_UINT8
3023 {
3024 $$ = AST_Expression::EV_uint8;
3025 }
3026 | IDL_UINT16
3027 {
3028 $$ = AST_Expression::EV_ushort;
3029 }
3030 | IDL_UINT32
3031 {
3032 $$ = AST_Expression::EV_ulong;
3033 }
3034 | IDL_UINT64
3035 {
3036 $$ = AST_Expression::EV_ulonglong;
3037 }
3038 ;
3040 floating_pt_type
3041 : IDL_DOUBLE
3042 {
3043 $$ = AST_Expression::EV_double;
3044 }
3045 | IDL_FLOAT
3046 {
3047 $$ = AST_Expression::EV_float;
3048 }
3049 | IDL_LONG IDL_DOUBLE
3050 {
3051 $$ = AST_Expression::EV_longdouble;
3052 }
3053 ;
3055 fixed_type
3056 : IDL_FIXED
3057 {
3058 $$ = AST_Expression::EV_fixed;
3059 }
3060 ;
3062 char_type
3063 : IDL_CHAR
3064 {
3065 $$ = AST_Expression::EV_char;
3066 }
3067 | IDL_WCHAR
3068 {
3069 $$ = AST_Expression::EV_wchar;
3070 }
3071 ;
3073 octet_type
3074 : IDL_OCTET
3075 {
3076 $$ = AST_Expression::EV_octet;
3077 }
3078 ;
3080 boolean_type
3081 : IDL_BOOLEAN
3082 {
3083 $$ = AST_Expression::EV_bool;
3084 }
3085 ;
3087 any_type
3088 : IDL_ANY
3089 {
3090 $$ = AST_Expression::EV_any;
3091 }
3092 ;
3094 object_type
3095 : IDL_OBJECT
3096 {
3097 $$ = AST_Expression::EV_object;
3098 }
3099 ;
3101 struct_decl :
3102 IDL_STRUCT
3103 {
3104 idl_global->set_parse_state (IDL_GlobalData::PS_StructSeen);
3105 }
3106 defining_id
3107 {
3108 idl_global->set_parse_state (IDL_GlobalData::PS_StructIDSeen);
3109 $$ = $3;
3110 }
3111 ;
3114 struct_type
3115 : struct_decl
3116 {
3117 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3118 UTL_ScopedName n ($1, 0);
3119 AST_Structure *d = 0;
3121 /*
3122 * Create a node representing a struct declaration. Add it
3123 * to the enclosing scope
3124 */
3125 if (s != 0)
3126 {
3127 d =
3128 idl_global->gen ()->create_structure (
3129 &n,
3130 s->is_local (),
3131 s->is_abstract ()
3132 );
3133 AST_Structure::fwd_redefinition_helper (d, s);
3134 (void) s->fe_add_structure (d);
3135 }
3137 /*
3138 * Push the scope of the struct on the scopes stack.
3139 */
3140 idl_global->scopes ().push (d);
3142 $1->destroy ();
3143 delete $1;
3144 $1 = 0;
3145 }
3146 '{'
3147 {
3148 idl_global->set_parse_state (IDL_GlobalData::PS_StructSqSeen);
3149 }
3150 at_least_one_member
3151 {
3152 idl_global->set_parse_state (IDL_GlobalData::PS_StructBodySeen);
3153 }
3154 '}'
3155 {
3156 idl_global->set_parse_state (IDL_GlobalData::PS_StructQsSeen);
3158 /*
3159 * Done with this struct. Pop its scope off the scopes stack.
3160 */
3161 $$ = dynamic_cast<AST_Structure*> (
3162 idl_global->scopes ().top_non_null ()
3163 );
3164 idl_global->scopes ().pop ();
3165 }
3166 ;
3168 at_least_one_member : member members ;
3170 members
3171 : members member
3172 | %empty
3173 ;
3175 member
3176 : annotations_maybe member_i
3177 {
3178 AST_Annotation_Appls *annotations = $1;
3179 AST_Decls *members = $2;
3180 if (annotations && members)
3181 {
3182 for (size_t i = 0; i < members->size (); i++)
3183 {
3184 (*members)[i]->annotation_appls (*annotations);
3185 }
3186 }
3187 delete annotations;
3188 delete members;
3189 }
3190 ;
3192 member_i :
3193 type_spec
3194 {
3195 idl_global->set_parse_state (IDL_GlobalData::PS_MemberTypeSeen);
3196 }
3197 at_least_one_declarator
3198 {
3199 idl_global->set_parse_state (IDL_GlobalData::PS_MemberDeclsSeen);
3200 }
3201 ';'
3202 {
3203 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3204 FE_Declarator *d = 0;
3205 AST_Field *f = 0;
3206 idl_global->set_parse_state (IDL_GlobalData::PS_MemberDeclsCompleted);
3207 AST_Decls *members = 0;
3209 /*
3210 * Check for illegal recursive use of type.
3211 */
3212 if ($1 != 0
3213 && AST_illegal_recursive_type ($1))
3214 {
3215 idl_global->err ()->error1 (UTL_Error::EIDL_RECURSIVE_TYPE,
3216 $1);
3217 }
3218 /*
3219 * Create a node representing a struct or exception member
3220 * Add it to the enclosing scope.
3221 */
3222 else if (s && $1 && $3)
3223 {
3224 members = new AST_Decls;
3225 for (UTL_DecllistActiveIterator l ($3);
3226 !l.is_done ();
3227 l.next ())
3228 {
3229 d = l.item ();
3231 if (d == 0)
3232 {
3233 continue;
3234 }
3236 AST_Type *tp = d->compose ($1);
3238 if (tp == 0)
3239 {
3240 continue;
3241 }
3243 f = idl_global->gen ()->create_field (tp, d->name ());
3244 members->push_back (f);
3245 (void) s->fe_add_field (f);
3246 }
3247 }
3249 $3->destroy ();
3250 delete $3;
3251 $3 = 0;
3253 $$ = members;
3254 }
3255 | error
3256 {
3257 idl_global->err ()->syntax_error (idl_global->parse_state ());
3258 }
3259 ';'
3260 {
3261 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
3262 yyerrok;
3263 }
3264 ;
3266 union_decl :
3267 IDL_UNION
3268 {
3269 idl_global->set_parse_state (IDL_GlobalData::PS_UnionSeen);
3270 }
3271 defining_id
3272 {
3273 idl_global->set_parse_state (IDL_GlobalData::PS_UnionIDSeen);
3274 $$ = $3;
3275 }
3276 ;
3278 union_type
3279 : union_decl IDL_SWITCH
3280 {
3281 idl_global->set_parse_state (IDL_GlobalData::PS_SwitchSeen);
3282 }
3283 '('
3284 {
3285 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3286 UTL_ScopedName n ($1, 0);
3287 AST_Union *u = 0;
3288 idl_global->set_parse_state (IDL_GlobalData::PS_SwitchOpenParSeen);
3290 /*
3291 * Create a node representing an empty union. Add it to its enclosing
3292 * scope.
3293 */
3294 if (s != 0)
3295 {
3296 u = idl_global->gen ()->create_union (0,
3297 &n,
3298 s->is_local (),
3299 s->is_abstract ());
3301 AST_Structure *st = dynamic_cast<AST_Structure*> (u);
3302 AST_Structure::fwd_redefinition_helper (st, s);
3303 u = dynamic_cast<AST_Union*> (st);
3304 (void) s->fe_add_union (u);
3305 }
3307 /*
3308 * Push the scope of the union on the scopes stack
3309 */
3310 idl_global->scopes ().push (u);
3312 /*
3313 * Don't delete $1 yet; we'll need it a bit later.
3314 */
3315 }
3316 annotations_maybe switch_type_spec
3317 {
3318 idl_global->set_parse_state (IDL_GlobalData::PS_SwitchTypeSeen);
3319 }
3320 ')'
3321 {
3322 /*
3323 * The top of the scopes must be an empty union we added after we
3324 * encountered 'union <id> switch ('. Now we are ready to add a
3325 * correct one. Temporarily remove the top so that we setup the
3326 * correct union in a right scope.
3327 */
3328 UTL_Scope *top = idl_global->scopes ().top_non_null ();
3329 idl_global->scopes ().pop ();
3330 AST_Annotation_Appls *disc_annotations = $6;
3332 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3333 UTL_ScopedName n ($1, 0);
3334 idl_global->set_parse_state (IDL_GlobalData::PS_SwitchCloseParSeen);
3336 /*
3337 * Create a node representing a union.
3338 */
3339 if ($7 != 0 && s != 0)
3340 {
3341 AST_ConcreteType *tp =
3342 dynamic_cast<AST_ConcreteType*> ($7);
3344 if (tp == 0)
3345 {
3346 idl_global->err ()->not_a_type ($7);
3347 }
3348 else
3349 {
3350 /* Create a union with a correct discriminator. */
3351 AST_Union *u = 0;
3352 u = idl_global->gen ()->create_union (tp,
3353 &n,
3354 s->is_local (),
3355 s->is_abstract ());
3357 /* Narrow the enclosing scope. */
3358 AST_Union *e = dynamic_cast<AST_Union*> (top);
3360 e->redefine (u);
3361 e->disc_annotations (*disc_annotations); // Set Discriminator Annotations
3363 u->destroy ();
3364 delete u;
3365 }
3366 }
3368 /*
3369 * Restore the top.
3370 */
3371 idl_global->scopes ().push (top);
3373 $1->destroy ();
3374 delete $1;
3375 $1 = 0;
3377 delete disc_annotations;
3378 }
3379 '{'
3380 {
3381 idl_global->set_parse_state (IDL_GlobalData::PS_UnionSqSeen);
3382 }
3383 at_least_one_case_branch
3384 {
3385 idl_global->set_parse_state (IDL_GlobalData::PS_UnionBodySeen);
3386 }
3387 '}'
3388 {
3389 idl_global->set_parse_state (IDL_GlobalData::PS_UnionQsSeen);
3391 /*
3392 * Done with this union. Pop its scope from the scopes stack.
3393 */
3394 $$ = dynamic_cast<AST_Union*> (
3395 idl_global->scopes ().top_non_null ()
3396 );
3398 if ($$ != 0)
3399 {
3400 idl_global->scopes ().pop ();
3401 }
3402 }
3403 ;
3405 switch_type_spec :
3406 integer_type
3407 {
3408 $$ =
3409 idl_global->scopes ().bottom ()->lookup_primitive_type (
3410 $1
3411 );
3412 }
3413 | char_type
3414 {
3415 /* wchars are not allowed. */
3416 if ($1 == AST_Expression::EV_wchar)
3417 {
3418 idl_global->err ()->error0 (UTL_Error::EIDL_DISC_TYPE);
3419 }
3421 $$ =
3422 idl_global->scopes ().bottom ()->lookup_primitive_type (
3423 $1
3424 );
3425 }
3426 | octet_type
3427 {
3428 /* octets are not allowed. */
3429 idl_global->err ()->error0 (UTL_Error::EIDL_DISC_TYPE);
3430 $$ =
3431 idl_global->scopes ().bottom ()->lookup_primitive_type (
3432 $1
3433 );
3434 }
3435 | boolean_type
3436 {
3437 $$ =
3438 idl_global->scopes ().bottom ()->lookup_primitive_type (
3439 $1
3440 );
3441 }
3442 | enum_type
3443 | scoped_name
3444 {
3445 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3446 AST_Decl *d = 0;
3447 AST_PredefinedType *p = 0;
3448 AST_Typedef *t = 0;
3449 bool found = false;
3451 /*
3452 * The discriminator is a scoped name. Try to resolve to
3453 * one of the scalar types or to an enum. Thread through
3454 * typedef's to arrive at the base type at the end of the
3455 * chain.
3456 */
3457 d =
3458 s->lookup_by_name ($1);
3460 if (s != 0 && d != 0)
3461 {
3462 while (!found)
3463 {
3464 switch (d->node_type ())
3465 {
3466 case AST_Decl::NT_enum:
3467 $$ = d;
3468 found = true;
3469 break;
3470 case AST_Decl::NT_pre_defined:
3471 p = dynamic_cast<AST_PredefinedType*> (d);
3473 if (p != 0)
3474 {
3475 switch (p->pt ())
3476 {
3477 case AST_PredefinedType::PT_long:
3478 case AST_PredefinedType::PT_ulong:
3479 case AST_PredefinedType::PT_longlong:
3480 case AST_PredefinedType::PT_ulonglong:
3481 case AST_PredefinedType::PT_short:
3482 case AST_PredefinedType::PT_ushort:
3483 case AST_PredefinedType::PT_char:
3484 case AST_PredefinedType::PT_boolean:
3485 $$ = p;
3486 found = true;
3487 break;
3488 case AST_PredefinedType::PT_wchar:
3489 case AST_PredefinedType::PT_octet:
3490 /* octets and wchars are not allowed */
3491 idl_global->err ()->error0 (
3492 UTL_Error::EIDL_DISC_TYPE
3493 );
3494 $$ = 0;
3495 found = true;
3496 break;
3497 default:
3498 $$ = 0;
3499 found = true;
3500 break;
3501 }
3502 }
3503 else
3504 {
3505 $$ = 0;
3506 found = true;
3507 }
3509 break;
3510 case AST_Decl::NT_typedef:
3511 t = dynamic_cast<AST_Typedef*> (d);
3513 if (t != 0)
3514 {
3515 d = t->base_type ();
3516 }
3518 break;
3519 default:
3520 $$ = 0;
3521 found = true;
3522 break;
3523 }
3524 }
3525 }
3526 else
3527 {
3528 $$ = 0;
3529 }
3531 if ($$ == 0)
3532 {
3533 idl_global->err ()->lookup_error ($1);
3535 $1->destroy ();
3536 delete $1;
3537 $1 = 0;
3539 /* If we don't return here, we'll crash later.*/
3540 if (!idl_global->ignore_lookup_errors_)
3541 {
3542 return 1;
3543 }
3544 }
3546 $1->destroy ();
3547 delete $1;
3548 $1 = 0;
3549 }
3550 ;
3552 at_least_one_case_branch : case_branch case_branches ;
3554 case_branches
3555 : case_branches case_branch
3556 | %empty
3557 ;
3559 case_branch :
3560 at_least_one_case_label
3561 {
3562 idl_global->set_parse_state (IDL_GlobalData::PS_UnionLabelSeen);
3563 }
3564 annotations_maybe element_spec
3565 {
3566 idl_global->set_parse_state (IDL_GlobalData::PS_UnionElemSeen);
3567 }
3568 ';'
3569 {
3570 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3571 AST_UnionBranch *b = 0;
3572 AST_Annotation_Appls *annotations = $3;
3573 AST_Field *f = $4;
3574 idl_global->set_parse_state (IDL_GlobalData::PS_UnionElemCompleted);
3576 /*
3577 * Create several nodes representing branches of a union.
3578 * Add them to the enclosing scope (the union scope)
3579 */
3580 if (s != 0 && $1 != 0 && $4 != 0)
3581 {
3582 b =
3583 idl_global->gen ()->create_union_branch (
3584 $1,
3585 f->field_type (),
3586 f->name ()
3587 );
3588 b->annotation_appls (*annotations);
3589 (void) s->fe_add_union_branch (b);
3591 // f has passed its field type to the union branch,
3592 // but the rest still needs to be cleaned up.
3593 f->AST_Decl::destroy ();
3594 delete f;
3595 f = 0;
3596 }
3598 delete annotations;
3599 }
3600 | error
3601 {
3602 idl_global->err ()->syntax_error (idl_global->parse_state ());
3603 }
3604 ';'
3605 {
3606 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
3607 yyerrok;
3608 }
3609 ;
3611 at_least_one_case_label :
3612 case_label case_labels
3613 {
3614 ACE_NEW_RETURN ($<llval>$,
3615 UTL_LabelList ($1,
3616 $2),
3617 1);
3618 }
3619 ;
3621 case_labels
3622 : case_labels case_label
3623 {
3624 UTL_LabelList *ll = 0;
3625 ACE_NEW_RETURN (ll,
3626 UTL_LabelList ($2,
3627 0),
3628 1);
3630 if ($1 == 0)
3631 {
3632 $<llval>$ = ll;
3633 }
3634 else
3635 {
3636 $1->nconc (ll);
3637 $<llval>$ = $1;
3638 }
3639 }
3640 | %empty
3641 {
3642 $<llval>$ = 0;
3643 }
3644 ;
3646 case_label
3647 : IDL_DEFAULT
3648 {
3649 idl_global->set_parse_state (IDL_GlobalData::PS_DefaultSeen);
3650 }
3651 ':'
3652 {
3653 idl_global->set_parse_state (IDL_GlobalData::PS_LabelColonSeen);
3655 $$ = idl_global->gen ()->create_union_label (
3656 AST_UnionLabel::UL_default,
3657 0
3658 );
3659 }
3660 | IDL_CASE
3661 {
3662 idl_global->set_parse_state (IDL_GlobalData::PS_CaseSeen);
3663 }
3664 const_expr
3665 {
3666 idl_global->set_parse_state (IDL_GlobalData::PS_LabelExprSeen);
3667 }
3668 ':'
3669 {
3670 idl_global->set_parse_state (IDL_GlobalData::PS_LabelColonSeen);
3672 $$ = idl_global->gen ()->create_union_label (
3673 AST_UnionLabel::UL_label,
3674 $3
3675 );
3676 }
3677 ;
3679 element_spec :
3680 type_spec
3681 {
3682 idl_global->set_parse_state (IDL_GlobalData::PS_UnionElemTypeSeen);
3683 }
3684 declarator
3685 {
3686 idl_global->set_parse_state (IDL_GlobalData::PS_UnionElemDeclSeen);
3688 /*
3689 * Check for illegal recursive use of type
3690 */
3691 if ($1 != 0
3692 && AST_illegal_recursive_type ($1))
3693 {
3694 idl_global->err ()->error1 (UTL_Error::EIDL_RECURSIVE_TYPE, $1);
3696 $$ = 0;
3697 }
3698 /*
3699 * Create a field in a union branch
3700 */
3701 else if ($1 == 0
3702 || $3 == 0)
3703 {
3704 $$ = 0;
3705 }
3706 else
3707 {
3708 AST_Type *tp = $3->compose ($1);
3710 if (tp == 0)
3711 {
3712 $$ = 0;
3713 }
3714 else
3715 {
3716 $$ = idl_global->gen ()->create_field (
3717 tp,
3718 $3->name ()
3719 );
3720 }
3722 $3->destroy ();
3723 delete $3;
3724 $3 = 0;
3725 }
3726 }
3727 ;
3729 struct_forward_type
3730 : struct_decl
3731 {
3732 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3733 UTL_ScopedName n ($1,
3734 0);
3735 AST_StructureFwd *d = 0;
3737 /*
3738 * Create a node representing a forward declaration of a struct.
3739 */
3740 if (s != 0)
3741 {
3742 d = idl_global->gen ()->create_structure_fwd (&n);
3743 (void) s->fe_add_structure_fwd (d);
3744 }
3746 $1->destroy ();
3747 delete $1;
3748 $1 = 0;
3750 $$ = d;
3751 }
3752 ;
3754 union_forward_type
3755 : union_decl
3756 {
3757 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3758 UTL_ScopedName n ($1,
3759 0);
3760 AST_UnionFwd *u = 0;
3762 /*
3763 * Create a node representing a forward declaration of a union.
3764 */
3765 if (s != 0)
3766 {
3767 u = idl_global->gen ()->create_union_fwd (&n);
3768 (void) s->fe_add_union_fwd (u);
3769 }
3771 $1->destroy ();
3772 delete $1;
3773 $1 = 0;
3774 }
3775 ;
3777 enum_type :
3778 IDL_ENUM
3779 {
3780 idl_global->set_parse_state (IDL_GlobalData::PS_EnumSeen);
3781 }
3782 defining_id
3783 {
3784 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3785 UTL_ScopedName n ($3, 0);
3786 AST_Enum *e = 0;
3787 idl_global->set_parse_state (IDL_GlobalData::PS_EnumIDSeen);
3789 /*
3790 * Create a node representing an enum and add it to its
3791 * enclosing scope.
3792 */
3793 if (s != 0)
3794 {
3795 e = idl_global->gen ()->create_enum (&n,
3796 s->is_local (),
3797 s->is_abstract ());
3798 /*
3799 * Add it to its defining scope
3800 */
3801 (void) s->fe_add_enum (e);
3802 }
3804 /*
3805 * Push the enum scope on the scopes stack.
3806 */
3807 idl_global->scopes ().push (e);
3809 $3->destroy ();
3810 delete $3;
3811 $3 = 0;
3812 }
3813 '{'
3814 {
3815 idl_global->set_parse_state (IDL_GlobalData::PS_EnumSqSeen);
3816 }
3817 at_least_one_enumerator
3818 {
3819 idl_global->set_parse_state (IDL_GlobalData::PS_EnumBodySeen);
3820 }
3821 '}'
3822 {
3823 idl_global->set_parse_state (IDL_GlobalData::PS_EnumQsSeen);
3825 /*
3826 * Done with this enum. Pop its scope from the scopes stack.
3827 */
3828 if (idl_global->scopes ().top () == 0)
3829 {
3830 $$ = 0;
3831 }
3832 else
3833 {
3834 $$ = dynamic_cast<AST_Enum*> (
3835 idl_global->scopes ().top_non_null ()
3836 );
3837 idl_global->scopes ().pop ();
3838 }
3839 }
3840 ;
3842 at_least_one_enumerator : enumerator enumerators ;
3844 enumerators
3845 : enumerators
3846 ','
3847 {
3848 idl_global->set_parse_state (IDL_GlobalData::PS_EnumCommaSeen);
3849 }
3850 enumerator
3851 | %empty
3852 ;
3854 enumerator :
3855 annotations_maybe IDENTIFIER
3856 {
3857 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3858 AST_Annotation_Appls *annotations = $1;
3859 Identifier id ($2);
3860 ACE::strdelete ($2);
3861 $2 = 0;
3862 UTL_ScopedName n (&id, 0);
3863 AST_EnumVal *e = 0;
3864 AST_Enum *c = 0;
3866 /*
3867 * Create a node representing one enumerator in an enum
3868 * Add it to the enclosing scope (the enum scope)
3869 */
3870 if (s != 0
3871 && s->scope_node_type () == AST_Decl::NT_enum)
3872 {
3873 c = dynamic_cast<AST_Enum*> (s);
3875 if (c != 0)
3876 {
3877 e = idl_global->gen ()->create_enum_val (
3878 c->next_enum_val (),
3879 &n
3880 );
3881 e->enum_parent (c);
3882 e->annotation_appls (*annotations);
3883 }
3885 (void) s->fe_add_enum_val (e);
3886 }
3888 delete annotations;
3889 }
3890 ;
3892 sequence_type_spec
3893 : seq_head
3894 ','
3895 {
3896 idl_global->set_parse_state (IDL_GlobalData::PS_SequenceCommaSeen);
3897 }
3898 positive_int_expr
3899 {
3900 idl_global->set_parse_state (IDL_GlobalData::PS_SequenceExprSeen);
3901 }
3902 '>'
3903 {
3904 idl_global->set_parse_state (IDL_GlobalData::PS_SequenceQsSeen);
3906 AST_Sequence *seq = 0;
3907 Decl_Annotations_Pair *seq_head = $1;
3908 AST_Decl *type = 0;
3909 AST_Annotation_Appls *type_annotations = 0;
3910 if (seq_head)
3911 {
3912 type = seq_head->decl;
3913 type_annotations = seq_head->annotations;
3914 }
3915 delete seq_head;
3917 /*
3918 * Remove sequence marker from scopes stack.
3919 */
3920 if (idl_global->scopes ().top () == 0)
3921 {
3922 idl_global->scopes ().pop ();
3923 }
3925 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3927 /*
3928 * Create a node representing a sequence
3929 */
3930 AST_Expression::AST_ExprValue *ev = 0;
3931 AST_Param_Holder *param_holder = 0;
3933 if ($4 != 0)
3934 {
3935 param_holder =
3936 $4->param_holder ();
3938 ev = $4->coerce (AST_Expression::EV_ulong);
3939 }
3941 // If the expression corresponds to a template parameter,
3942 // it's ok for the coercion to fail at this point. We check
3943 // for a type mismatch below.
3944 if (0 == $4
3945 || (0 == ev && 0 == param_holder))
3946 {
3947 idl_global->err ()->coercion_error ($4,
3948 AST_Expression::EV_ulong);
3949 }
3950 else if (type)
3951 {
3952 AST_Type *tp = dynamic_cast<AST_Type*> (type);
3954 if (0 == tp)
3955 {
3956 ; // Error will be caught in FE_Declarator.
3957 }
3958 else
3959 {
3960 Identifier id ("sequence");
3961 UTL_ScopedName sn (&id,
3962 0);
3964 seq =
3965 idl_global->gen ()->create_sequence (
3966 $4,
3967 tp,
3968 &sn,
3969 s->is_local (),
3970 s->is_abstract ()
3971 );
3972 seq->base_type_annotations (*type_annotations);
3974 idl_global->err ()->anonymous_type_diagnostic ();
3975 }
3976 }
3978 delete type_annotations;
3979 delete ev;
3980 ev = 0;
3981 $$ = seq;
3982 }
3983 | seq_head
3984 '>'
3985 {
3986 idl_global->set_parse_state (IDL_GlobalData::PS_SequenceQsSeen);
3988 AST_Sequence *seq = 0;
3989 Decl_Annotations_Pair *seq_head = $1;
3990 AST_Decl *type = 0;
3991 AST_Annotation_Appls *type_annotations = 0;
3992 if (seq_head)
3993 {
3994 type = seq_head->decl;
3995 type_annotations = seq_head->annotations;
3996 }
3997 delete seq_head;
3999 /*
4000 * Remove sequence marker from scopes stack.
4001 */
4002 if (idl_global->scopes ().top () == 0)
4003 {
4004 idl_global->scopes ().pop ();
4005 }
4007 UTL_Scope *s = idl_global->scopes ().top_non_null ();
4009 /*
4010 * Create a node representing a sequence.
4011 */
4012 if (type)
4013 {
4014 AST_Type *tp = dynamic_cast<AST_Type*> (type);
4016 if (tp == 0)
4017 {
4018 ; // Error will be caught in FE_Declarator.
4019 }
4020 else
4021 {
4022 Identifier id ("sequence");
4023 UTL_ScopedName sn (&id, 0);
4024 ACE_CDR::ULong bound = 0UL;
4026 seq =
4027 idl_global->gen ()->create_sequence (
4028 idl_global->gen ()->create_expr (
4029 bound,
4030 AST_Expression::EV_ulong
4031 ),
4032 tp,
4033 &sn,
4034 s->is_local (),
4035 s->is_abstract ()
4036 );
4037 seq->base_type_annotations (*type_annotations);
4039 idl_global->err ()->anonymous_type_diagnostic ();
4040 }
4041 }
4043 delete type_annotations;
4044 $$ = seq;
4045 }
4046 ;
4048 seq_head :
4049 IDL_SEQUENCE
4050 {
4051 idl_global->set_parse_state (IDL_GlobalData::PS_SequenceSeen);
4053 /*
4054 * Push a sequence marker on scopes stack.
4055 */
4056 idl_global->scopes ().push (0);
4057 }
4058 '<'
4059 {
4060 idl_global->set_parse_state (IDL_GlobalData::PS_SequenceSqSeen);
4061 }
4062 annotations_maybe simple_type_spec
4063 {
4064 idl_global->set_parse_state (IDL_GlobalData::PS_SequenceTypeSeen);
4065 Decl_Annotations_Pair *seq_head = new Decl_Annotations_Pair;
4066 seq_head->decl = $6;
4067 seq_head->annotations = $5;
4068 $$ = seq_head;
4069 }
4070 ;
4072 fixed_type_spec
4073 : IDL_FIXED '<' positive_int_expr ',' const_expr '>'
4074 {
4075 $5->evaluate (AST_Expression::EK_positive_int);
4076 $$ = idl_global->gen ()->create_fixed ($3, $5);
4077 }
4078 ;
4080 string_type_spec
4081 : string_head
4082 '<'
4083 {
4084 idl_global->set_parse_state (IDL_GlobalData::PS_StringSqSeen);
4085 }
4086 positive_int_expr
4087 {
4088 idl_global->set_parse_state (IDL_GlobalData::PS_StringExprSeen);
4089 }
4090 '>'
4091 {
4092 idl_global->set_parse_state (IDL_GlobalData::PS_StringQsSeen);
4094 /*
4095 * Create a node representing a string.
4096 */
4097 AST_Expression::AST_ExprValue *ev = 0;
4099 if ($4 != 0)
4100 {
4101 ev = $4->coerce (AST_Expression::EV_ulong);
4102 }
4104 if (0 == $4 || 0 == ev)
4105 {
4106 idl_global->err ()->coercion_error ($4,
4107 AST_Expression::EV_ulong);
4108 $$ = 0;
4109 }
4110 else
4111 {
4112 tao_string_decl = idl_global->gen ()->create_string ($4);
4114 /*
4115 * Add this AST_String to the types defined in the global scope.
4116 */
4117 idl_global->root ()->fe_add_string (
4118 dynamic_cast<AST_String*> (
4119 tao_string_decl));
4121 idl_global->err ()->anonymous_type_diagnostic ();
4123 $$ = tao_string_decl;
4124 }
4126 delete ev;
4127 ev = 0;
4128 }
4129 | string_head
4130 {
4131 idl_global->set_parse_state (IDL_GlobalData::PS_StringCompleted);
4133 /*
4134 * Create a node representing a string.
4135 */
4136 ACE_CDR::ULong bound = 0UL;
4137 tao_string_decl =
4138 idl_global->gen ()->create_string (
4139 idl_global->gen ()->create_expr (bound,
4140 AST_Expression::EV_ulong)
4141 );
4143 /*
4144 * Add this AST_String to the types defined in the global scope.
4145 */
4146 idl_global->root ()->fe_add_string (
4147 dynamic_cast<AST_String*> (
4148 tao_string_decl));
4150 $$ = tao_string_decl;
4151 }
4152 ;
4154 string_head :
4155 IDL_STRING
4156 {
4157 idl_global->set_parse_state (IDL_GlobalData::PS_StringSeen);
4158 }
4159 ;
4161 wstring_type_spec
4162 : wstring_head
4163 '<'
4164 {
4165 idl_global->set_parse_state (IDL_GlobalData::PS_StringSqSeen);
4166 }
4167 positive_int_expr
4168 {
4169 idl_global->set_parse_state (IDL_GlobalData::PS_StringExprSeen);
4170 }
4171 '>'
4172 {
4173 idl_global->set_parse_state (IDL_GlobalData::PS_StringQsSeen);
4175 /*
4176 * Create a node representing a string.
4177 */
4178 AST_Expression::AST_ExprValue *ev = 0;
4180 if ($4 != 0)
4181 {
4182 ev = $4->coerce (AST_Expression::EV_ulong);
4183 }
4185 if (0 == $4 || 0 == ev)
4186 {
4187 idl_global->err ()->coercion_error ($4,
4188 AST_Expression::EV_ulong);
4189 $$ = 0;
4190 }
4191 else
4192 {
4193 AST_String *string = idl_global->gen ()->create_wstring ($4);
4195 /*
4196 * Add this AST_String to the types defined in the global scope.
4197 */
4198 idl_global->root ()->fe_add_string (
4199 dynamic_cast<AST_String*> (
4200 string));
4202 idl_global->err ()->anonymous_type_diagnostic ();
4204 $$ = string;
4205 }
4207 delete ev;
4208 ev = 0;
4209 }
4210 | wstring_head
4211 {
4212 idl_global->set_parse_state (IDL_GlobalData::PS_StringCompleted);
4214 /*
4215 * Create a node representing a wstring.
4216 */
4217 ACE_CDR::ULong bound = 0UL;
4218 AST_String *string =
4219 idl_global->gen ()->create_wstring (
4220 idl_global->gen ()->create_expr (bound,
4221 AST_Expression::EV_ulong)
4222 );
4224 /*
4225 * Add this AST_String to the types defined in the global scope.
4226 */
4227 idl_global->root ()->fe_add_string (
4228 dynamic_cast<AST_String*> (
4229 string));
4231 $$ = string;
4232 }
4233 ;
4235 wstring_head :
4236 IDL_WSTRING
4237 {
4238 idl_global->set_parse_state (IDL_GlobalData::PS_StringSeen);
4239 }
4240 ;
4242 array_declarator :
4243 defining_id
4244 {
4245 idl_global->set_parse_state (IDL_GlobalData::PS_ArrayIDSeen);
4246 }
4247 annotations_maybe at_least_one_array_dim
4248 {
4249 idl_global->set_parse_state (IDL_GlobalData::PS_ArrayCompleted);
4251 AST_Array *array = 0;
4252 AST_Annotation_Appls *base_type_annotations = $3;
4253 UTL_ExprList *array_dims = $4;
4255 /*
4256 * Create a node representing an array.
4257 */
4258 if (array_dims)
4259 {
4260 UTL_ScopedName sn ($1,
4261 0);
4262 array =
4263 idl_global->gen ()->create_array (
4264 &sn,
4265 array_dims->length (),
4266 array_dims,
4267 0,
4268 0
4269 );
4270 array->base_type_annotations (*base_type_annotations);
4271 sn.destroy ();
4273 idl_global->err ()->anonymous_type_diagnostic ();
4274 }
4276 array_dims->destroy ();
4277 delete array_dims;
4279 delete base_type_annotations;
4281 $$ = array;
4282 }
4283 ;
4285 at_least_one_array_dim :
4286 array_dim array_dims
4287 {
4288 ACE_NEW_RETURN ($$,
4289 UTL_ExprList ($1,
4290 $2),
4291 1);
4292 }
4293 ;
4295 array_dims
4296 : array_dims array_dim
4297 {
4298 UTL_ExprList *el = 0;
4299 ACE_NEW_RETURN (el,
4300 UTL_ExprList ($2,
4301 0),
4302 1);
4304 if ($1 == 0)
4305 {
4306 $$ = el;
4307 }
4308 else
4309 {
4310 $1->nconc (el);
4311 $$ = $1;
4312 }
4313 }
4314 | %empty
4315 {
4316 $$ = 0;
4317 }
4318 ;
4320 array_dim :
4321 '['
4322 {
4323 idl_global->set_parse_state (IDL_GlobalData::PS_DimSqSeen);
4324 }
4325 positive_int_expr
4326 {
4327 idl_global->set_parse_state (IDL_GlobalData::PS_DimExprSeen);
4328 }
4329 ']'
4330 {
4331 idl_global->set_parse_state (IDL_GlobalData::PS_DimQsSeen);
4333 /*
4334 * Array dimensions are expressions which must be coerced to
4335 * positive integers.
4336 */
4337 AST_Expression::AST_ExprValue *ev = 0;
4338 AST_Param_Holder *param_holder = 0;
4340 if ($3 != 0)
4341 {
4342 param_holder =
4343 $3->param_holder ();
4345 ev =
4346 $3->coerce (AST_Expression::EV_ulong);
4347 }
4349 if (0 == $3
4350 || (ev == 0 && param_holder == 0))
4351 {
4352 idl_global->err ()->coercion_error ($3,
4353 AST_Expression::EV_ulong);
4354 $$ = 0;
4355 }
4356 else
4357 {
4358 if (param_holder != 0)
4359 {
4360 AST_Expression::ExprType et =
4361 param_holder->info ()->const_type_;
4363 // If the bound expression represents a
4364 // template parameter, it must be a const
4365 // and of type unsigned long.
4366 if (et != AST_Expression::EV_ulong)
4367 {
4368 idl_global->err ()->mismatched_template_param (
4369 param_holder->info ()->name_.c_str ());
4371 delete ev;
4372 ev = 0;
4373 return 1;
4374 }
4375 }
4377 $$ = $3;
4378 }
4380 delete ev;
4381 ev = 0;
4382 }
4383 ;
4385 attribute
4386 : attribute_readonly
4387 | attribute_readwrite
4388 ;
4390 attribute_readonly :
4391 IDL_READONLY
4392 {
4393 idl_global->set_parse_state (IDL_GlobalData::PS_AttrROSeen);
4394 }
4395 IDL_ATTRIBUTE
4396 {
4397 idl_global->set_parse_state (IDL_GlobalData::PS_AttrSeen);
4398 }
4399 param_type_spec
4400 {
4401 idl_global->set_parse_state (IDL_GlobalData::PS_AttrTypeSeen);
4402 }
4403 at_least_one_simple_declarator
4404 {
4405 idl_global->set_parse_state (IDL_GlobalData::PS_AttrDeclsSeen);
4406 }
4407 opt_raises
4408 {
4409 UTL_Scope *s = idl_global->scopes ().top_non_null ();
4410 AST_Attribute *a = 0;
4411 FE_Declarator *d = 0;
4413 idl_global->set_parse_state (IDL_GlobalData::PS_OpRaiseCompleted);
4415 /*
4416 * Create nodes representing attributes and add them to the
4417 * enclosing scope.
4418 */
4419 if (s != 0 && $5 != 0 && $7 != 0)
4420 {
4421 for (UTL_DecllistActiveIterator l ($7); !l.is_done (); l.next ())
4422 {
4423 d = l.item ();
4425 if (d == 0)
4426 {
4427 continue;
4428 }
4430 AST_Type *tp = d->compose ($5);
4432 if (tp == 0)
4433 {
4434 continue;
4435 }
4437 a = idl_global->gen ()->create_attribute (
4438 true, tp, d->name (), s->is_local (), s->is_abstract ());
4440 if ($9 != 0)
4441 {
4442 (void) a->fe_add_get_exceptions ($9);
4444 $9->destroy ();
4445 delete $9;
4446 $9 = 0;
4447 }
4449 (void) s->fe_add_attribute (a);
4450 }
4451 }
4453 $7->destroy ();
4454 delete $7;
4455 $7 = 0;
4457 $$ = a;
4458 }
4459 ;
4461 attribute_readwrite :
4462 IDL_ATTRIBUTE
4463 {
4464 idl_global->set_parse_state (IDL_GlobalData::PS_AttrSeen);
4465 }
4466 param_type_spec
4467 {
4468 idl_global->set_parse_state (IDL_GlobalData::PS_AttrTypeSeen);
4469 }
4470 at_least_one_simple_declarator
4471 {
4472 idl_global->set_parse_state (IDL_GlobalData::PS_AttrDeclsSeen);
4473 }
4474 opt_getraises
4475 {
4476 idl_global->set_parse_state (IDL_GlobalData::PS_OpGetRaiseCompleted);
4477 }
4478 opt_setraises
4479 {
4480 UTL_Scope *s = idl_global->scopes ().top_non_null ();
4481 AST_Attribute *a = 0;
4482 FE_Declarator *d = 0;
4484 idl_global->set_parse_state (IDL_GlobalData::PS_OpSetRaiseCompleted);
4486 /*
4487 * Create nodes representing attributes and add them to the
4488 * enclosing scope.
4489 */
4490 if (s != 0 && $3 != 0 && $5 != 0)
4491 {
4492 for (UTL_DecllistActiveIterator l ($5); !l.is_done (); l.next ())
4493 {
4494 d = l.item ();
4496 if (d == 0)
4497 {
4498 continue;
4499 }
4501 AST_Type *tp = d->compose ($3);
4503 if (tp == 0)
4504 {
4505 continue;
4506 }
4508 a = idl_global->gen ()->create_attribute (
4509 false, tp, d->name (), s->is_local (), s->is_abstract ());
4511 if ($7 != 0)
4512 {
4513 (void) a->fe_add_get_exceptions ($7);
4515 $7->destroy ();
4516 delete $7;
4517 $7 = 0;
4518 }
4520 if ($9 != 0)
4521 {
4522 (void) a->fe_add_set_exceptions ($9);
4524 $9->destroy ();
4525 delete $9;
4526 $9 = 0;
4527 }
4529 (void) s->fe_add_attribute (a);
4530 }
4531 }
4533 $5->destroy ();
4534 delete $5;
4535 $5 = 0;
4537 $$ = a;
4538 }
4539 ;
4541 exception :
4542 IDL_EXCEPTION
4543 {
4544 idl_global->set_parse_state (IDL_GlobalData::PS_ExceptSeen);
4545 }
4546 defining_id
4547 {
4548 Identifier *&id = $3;
4549 UTL_Scope *scope = idl_global->scopes ().top_non_null ();
4550 UTL_ScopedName scoped_name (id, 0);
4551 AST_Exception *exception = 0;
4552 idl_global->set_parse_state (IDL_GlobalData::PS_ExceptIDSeen);
4554 /*
4555 * Create a node representing an exception and add it to
4556 * the enclosing scope.
4557 */
4558 if (scope)
4559 {
4560 exception = idl_global->gen ()->create_exception (
4561 &scoped_name,
4562 scope->is_local (),
4563 scope->is_abstract ());
4564 scope->fe_add_exception (exception);
4565 }
4567 /*
4568 * Push the exception scope on the scope stack.
4569 */
4570 idl_global->scopes ().push (exception);
4572 id->destroy ();
4573 delete id;
4574 id = 0;
4576 $<dcval>$ = exception;
4577 }
4578 '{'
4579 {
4580 idl_global->set_parse_state (IDL_GlobalData::PS_ExceptSqSeen);
4581 }
4582 members
4583 {
4584 idl_global->set_parse_state (IDL_GlobalData::PS_ExceptBodySeen);
4585 }
4586 '}'
4587 {
4588 idl_global->set_parse_state (IDL_GlobalData::PS_ExceptQsSeen);
4589 /*
4590 * Done with this exception. Pop its scope from the scope stack.
4591 */
4592 idl_global->scopes ().pop ();
4594 $$ = $<dcval>4;
4595 }
4596 ;
4598 operation
4599 : opt_op_attribute op_type_spec
4600 {
4601 idl_global->set_parse_state (IDL_GlobalData::PS_OpTypeSeen);
4602 }
4603 IDENTIFIER
4604 {
4605 AST_Operation *op = 0;
4606 UTL_Scope *scope = idl_global->scopes ().top_non_null ();
4608 AST_Operation::Flags op_flags = $1;
4609 AST_Decl *type_node = $2;
4610 $2 = 0;
4611 Identifier id ($4);
4612 ACE::strdelete ($4);
4613 $4 = 0;
4615 UTL_ScopedName name (&id, 0);
4616 idl_global->set_parse_state (IDL_GlobalData::PS_OpIDSeen);
4618 /*
4619 * Create a node representing an operation on an interface
4620 * and add it to its enclosing scope.
4621 */
4622 if (scope != 0 && type_node != 0)
4623 {
4624 AST_Type *type = dynamic_cast<AST_Type*> (type_node);
4626 if (type == 0)
4627 {
4628 idl_global->err ()->not_a_type (type_node);
4629 }
4630 else if (type->node_type () == AST_Decl::NT_except)
4631 {
4632 idl_global->err ()->not_a_type (type_node);
4633 }
4634 else
4635 {
4636 AST_Decl *d = ScopeAsDecl (scope);
4637 AST_Decl::NodeType nt = d->node_type ();
4638 const bool local = scope->is_local ()
4639 || nt == AST_Decl::NT_valuetype
4640 || nt == AST_Decl::NT_eventtype;
4642 op = idl_global->gen ()->create_operation (
4643 type, op_flags, &name, local, scope->is_abstract ());
4645 if (!local && type->is_local ())
4646 {
4647 idl_global->err ()->local_remote_mismatch (type, op);
4648 op->destroy ();
4649 delete op;
4650 op = 0;
4651 }
4652 else
4653 {
4654 scope->fe_add_operation (op);
4655 }
4656 }
4657 }
4659 /*
4660 * Push the operation scope onto the scopes stack.
4661 */
4662 idl_global->scopes ().push (op);
4663 }
4664 parameter_list
4665 {
4666 idl_global->set_parse_state (IDL_GlobalData::PS_OpParsCompleted);
4667 }
4668 opt_raises
4669 {
4670 idl_global->set_parse_state (IDL_GlobalData::PS_OpRaiseCompleted);
4671 }
4672 opt_context
4673 {
4674 UTL_Scope *s = idl_global->scopes ().top_non_null ();
4675 AST_Operation *o = 0;
4676 idl_global->set_parse_state (IDL_GlobalData::PS_OpCompleted);
4678 /*
4679 * Add exceptions and context to the operation.
4680 */
4681 if (s != 0 && s->scope_node_type () == AST_Decl::NT_op)
4682 {
4683 o = dynamic_cast<AST_Operation*> (s);
4685 if ($8 != 0 && o != 0)
4686 {
4687 (void) o->fe_add_exceptions ($8);
4688 }
4690 if ($10 != 0)
4691 {
4692 (void) o->fe_add_context ($10);
4693 }
4694 }
4696 /*
4697 * Done with this operation. Pop its scope from the scopes stack.
4698 */
4699 idl_global->scopes ().pop ();
4701 $$ = o;
4702 }
4703 ;
4705 opt_op_attribute
4706 : IDL_ONEWAY
4707 {
4708 idl_global->set_parse_state (IDL_GlobalData::PS_OpAttrSeen);
4709 $$ = AST_Operation::OP_oneway;
4710 }
4711 | IDL_IDEMPOTENT
4712 {
4713 idl_global->set_parse_state (IDL_GlobalData::PS_OpAttrSeen);
4714 $$ = AST_Operation::OP_idempotent;
4715 }
4716 | %empty
4717 {
4718 $$ = AST_Operation::OP_noflags;
4719 }
4720 ;
4722 op_type_spec
4723 : param_type_spec
4724 | IDL_VOID
4725 {
4726 $$ =
4727 idl_global->scopes ().bottom ()->lookup_primitive_type (
4728 AST_Expression::EV_void
4729 );
4730 }
4731 ;
4733 init_decl
4734 : IDL_FACTORY
4735 {
4736 //@@ PS_FactorySeen?
4737 idl_global->set_parse_state (IDL_GlobalData::PS_OpTypeSeen);
4738 }
4739 IDENTIFIER
4740 {
4741 UTL_Scope *s = idl_global->scopes ().top_non_null ();
4743 if (s->is_abstract ())
4744 {
4745 //@@ Fire error
4746 ACE_ERROR ((LM_ERROR,
4747 ACE_TEXT ("error in %C line %d:\n")
4748 ACE_TEXT ("Abstract valuetype can't have a ")
4749 ACE_TEXT ("factory construct.\n"),
4750 idl_global->filename ()->get_string (),
4751 idl_global->lineno ()));
4753 idl_global->set_err_count (idl_global->err_count () + 1);
4754 }
4756 Identifier id ($3);
4757 ACE::strdelete ($3);
4758 $3 = 0;
4760 UTL_ScopedName n (&id,
4761 0);
4762 AST_Factory *factory = 0;
4763 idl_global->set_parse_state (IDL_GlobalData::PS_OpIDSeen);
4765 /*
4766 * Create a node representing an factory construct
4767 * and add it to its enclosing scope
4768 */
4769 if (s != 0)
4770 {
4771 factory = idl_global->gen ()->create_factory (&n);
4772 (void) s->fe_add_factory (factory);
4773 }
4775 /*
4776 * Push the operation scope onto the scopes stack.
4777 */
4778 idl_global->scopes ().push (factory);
4780 $<dcval>$ = factory;
4781 }
4782 init_parameter_list
4783 {
4784 idl_global->set_parse_state (IDL_GlobalData::PS_OpParsCompleted);
4785 }
4786 opt_raises
4787 {
4788 idl_global->set_parse_state (IDL_GlobalData::PS_OpRaiseCompleted);
4790 if ($7)
4791 {
4792 UTL_Scope *s = idl_global->scopes ().top_non_null ();
4793 AST_Factory *f = dynamic_cast<AST_Factory*> (s);
4794 (void) f->fe_add_exceptions ($7);
4795 }
4797 idl_global->scopes ().pop ();
4799 $$ = $<dcval>4;
4800 }
4801 ;
4803 init_parameter_list
4804 : '('
4805 {
4806 idl_global->set_parse_state (IDL_GlobalData::PS_OpSqSeen);
4807 }
4808 ')'
4809 {
4810 idl_global->set_parse_state (IDL_GlobalData::PS_OpQsSeen);
4811 }
4812 | '('
4813 {
4814 idl_global->set_parse_state (IDL_GlobalData::PS_OpSqSeen);
4815 }
4816 at_least_one_in_parameter
4817 ')'
4818 {
4819 idl_global->set_parse_state (IDL_GlobalData::PS_OpQsSeen);
4820 }
4821 ;
4823 at_least_one_in_parameter : in_parameter in_parameters ;
4825 in_parameters
4826 : in_parameters
4827 ','
4828 {
4829 idl_global->set_parse_state (IDL_GlobalData::PS_OpParCommaSeen);
4830 }
4831 in_parameter
4832 | %empty
4833 ;
4835 in_parameter :
4836 IDL_IN
4837 {
4838 idl_global->set_parse_state (IDL_GlobalData::PS_OpParDirSeen);
4839 }
4840 param_type_spec
4841 {
4842 idl_global->set_parse_state (IDL_GlobalData::PS_OpParTypeSeen);
4843 }
4844 declarator
4845 {
4846 UTL_Scope *s = idl_global->scopes ().top_non_null ();
4847 AST_Argument *a = 0;
4848 idl_global->set_parse_state (IDL_GlobalData::PS_OpParDeclSeen);
4850 /*
4851 * Create a node representing an argument to an operation
4852 * Add it to the enclosing scope (the operation scope).
4853 */
4854 if ($3 != 0
4855 && $5 != 0 &&
4856 s != 0)
4857 {
4858 AST_Type *tp = $5->compose ($3);
4860 if (tp != 0)
4861 {
4862 a = idl_global->gen ()->create_argument (
4863 AST_Argument::dir_IN,
4864 tp,
4865 $5->name ()
4866 );
4868 (void) s->fe_add_argument (a);
4869 }
4870 }
4872 $5->destroy ();
4873 delete $5;
4874 $5 = 0;
4875 }
4876 ;
4878 parameter_list
4879 : '('
4880 {
4881 idl_global->set_parse_state (IDL_GlobalData::PS_OpSqSeen);
4882 }
4883 ')'
4884 {
4885 idl_global->set_parse_state (IDL_GlobalData::PS_OpQsSeen);
4886 }
4887 | '('
4888 {
4889 idl_global->set_parse_state (IDL_GlobalData::PS_OpSqSeen);
4890 }
4891 at_least_one_parameter
4892 ')'
4893 {
4894 idl_global->set_parse_state (IDL_GlobalData::PS_OpQsSeen);
4895 }
4896 ;
4898 at_least_one_parameter : parameter parameters ;
4900 parameters
4901 : parameters
4902 ','
4903 {
4904 idl_global->set_parse_state (IDL_GlobalData::PS_OpParCommaSeen);
4905 }
4906 parameter
4907 | %empty
4908 ;
4910 parameter :
4911 direction
4912 {
4913 idl_global->set_parse_state (IDL_GlobalData::PS_OpParDirSeen);
4914 }
4915 param_type_spec
4916 {
4917 idl_global->set_parse_state (IDL_GlobalData::PS_OpParTypeSeen);
4918 }
4919 declarator
4920 {
4921 UTL_Scope *s = idl_global->scopes ().top_non_null ();
4922 AST_Argument *a = 0;
4923 idl_global->set_parse_state (IDL_GlobalData::PS_OpParDeclSeen);
4925 /*
4926 * Create a node representing an argument to an operation
4927 * Add it to the enclosing scope (the operation scope).
4928 */
4929 if ($3 != 0
4930 && $5 != 0
4931 && s != 0)
4932 {
4933 AST_Type *tp = $5->compose ($3);
4935 if (tp != 0)
4936 {
4937 if (!s->is_local () && tp->is_local ())
4938 {
4939 idl_global->err ()->local_remote_mismatch (tp, s);
4940 }
4941 else
4942 {
4943 a =
4944 idl_global->gen ()->create_argument (
4945 $1,
4946 tp,
4947 $5->name ()
4948 );
4949 (void) s->fe_add_argument (a);
4950 }
4951 }
4952 }
4954 $5->destroy ();
4955 delete $5;
4956 $5 = 0;
4957 }
4958 ;
4960 param_type_spec
4961 : base_type_spec
4962 {
4963 $$ =
4964 idl_global->scopes ().bottom ()->lookup_primitive_type (
4965 $1
4966 );
4967 }
4968 | string_type_spec
4969 | wstring_type_spec
4970 | scoped_name
4971 {
4972 UTL_Scope *s = idl_global->scopes ().top_non_null ();
4973 AST_Decl *d = 0;
4974 UTL_ScopedName *n = $1;
4976 if (s != 0)
4977 {
4978 d = s->lookup_by_name (n, false, false);
4979 }
4981 if (d == 0)
4982 {
4983 idl_global->err ()->lookup_error (n);
4984 $1->destroy ();
4985 $1 = 0;
4987 /* If we don't return here, we'll crash later.*/
4988 return 1;
4989 }
4990 else
4991 {
4992 d->last_referenced_as ($1);
4993 AST_Decl::NodeType nt = d->node_type ();
4994 AST_Type *t = dynamic_cast<AST_Type*> (d);
4995 AST_Typedef *td = 0;
4996 bool can_be_undefined = false;
4998 if (nt == AST_Decl::NT_typedef)
4999 {
5000 // This code block ensures that a sequence of
5001 // as-yet-undefined struct or union isn't used
5002 // as a return type or argument.
5003 td = dynamic_cast<AST_Typedef*> (d);
5004 AST_Type *pbt = td->primitive_base_type ();
5006 if (pbt->node_type () == AST_Decl::NT_sequence)
5007 {
5008 t = pbt;
5009 AST_Sequence *seq_type =
5010 dynamic_cast<AST_Sequence*> (pbt);
5011 AST_Type *elem_type =
5012 seq_type->base_type ();
5013 AST_Decl::NodeType elem_nt =
5014 elem_type->node_type ();
5016 if (elem_nt == AST_Decl::NT_typedef)
5017 {
5018 AST_Typedef *elem_td =
5019 dynamic_cast<AST_Typedef*> (elem_type);
5020 elem_type = elem_td->primitive_base_type ();
5021 elem_nt = elem_type->node_type ();
5022 }
5024 if (elem_nt == AST_Decl::NT_interface
5025 || elem_nt == AST_Decl::NT_interface_fwd
5026 || elem_nt == AST_Decl::NT_valuetype
5027 || elem_nt == AST_Decl::NT_valuetype_fwd
5028 || elem_nt == AST_Decl::NT_component
5029 || elem_nt == AST_Decl::NT_component_fwd)
5030 {
5031 can_be_undefined = true;
5032 }
5033 }
5035 if (! t->is_defined () && ! can_be_undefined)
5036 {
5037 idl_global->err ()->error1 (
5038 UTL_Error::EIDL_ILLEGAL_ADD,
5039 (nt == AST_Decl::NT_typedef ? td : t));
5041 /* If we don't return here, we'll crash later.*/
5042 return 1;
5043 }
5044 }
5045 else
5046 {
5047 // For forward declared structs and unions, we
5048 // want the full definition, but we need to
5049 // check that it's been fully defined.
5050 AST_StructureFwd *fwd =
5051 dynamic_cast<AST_StructureFwd*> (d);
5053 if (fwd != 0)
5054 {
5055 t = fwd->full_definition ();
5057 if (! t->is_defined ())
5058 {
5059 idl_global->err ()->error1 (
5060 UTL_Error::EIDL_ILLEGAL_ADD,
5061 t);
5063 /* If we don't return here, we'll crash later.*/
5064 return 1;
5065 }
5067 d = t;
5068 }
5069 }
5070 }
5072 $$ = d;
5073 }
5074 ;
5076 direction
5077 : IDL_IN
5078 {
5079 $$ = AST_Argument::dir_IN;
5080 }
5081 | IDL_OUT
5082 {
5083 $$ = AST_Argument::dir_OUT;
5084 }
5085 | IDL_INOUT
5086 {
5087 $$ = AST_Argument::dir_INOUT;
5088 }
5089 ;
5091 opt_raises
5092 : IDL_RAISES
5093 {
5094 idl_global->set_parse_state (IDL_GlobalData::PS_OpRaiseSeen);
5095 }
5096 '('
5097 {
5098 idl_global->set_parse_state (IDL_GlobalData::PS_OpRaiseSqSeen);
5099 }
5100 at_least_one_scoped_name
5101 ')'
5102 {
5103 idl_global->set_parse_state (IDL_GlobalData::PS_OpRaiseQsSeen);
5104 $$ = $5;
5105 }
5106 | %empty
5107 {
5108 $$ = 0;
5109 }
5110 ;
5112 opt_getraises
5113 : IDL_GETRAISES
5114 {
5115 idl_global->set_parse_state (IDL_GlobalData::PS_OpGetRaiseSeen);
5116 }
5117 '('
5118 {
5119 idl_global->set_parse_state (IDL_GlobalData::PS_OpGetRaiseSqSeen);
5120 }
5121 at_least_one_scoped_name
5122 ')'
5123 {
5124 idl_global->set_parse_state (IDL_GlobalData::PS_OpGetRaiseQsSeen);
5125 $$ = $5;
5126 }
5127 | %empty
5128 {
5129 $$ = 0;
5130 }
5131 ;
5133 opt_setraises
5134 : IDL_SETRAISES
5135 {
5136 idl_global->set_parse_state (IDL_GlobalData::PS_OpSetRaiseSeen);
5137 }
5138 '('
5139 {
5140 idl_global->set_parse_state (IDL_GlobalData::PS_OpSetRaiseSqSeen);
5141 }
5142 at_least_one_scoped_name
5143 ')'
5144 {
5145 idl_global->set_parse_state (IDL_GlobalData::PS_OpSetRaiseQsSeen);
5146 $$ = $5;
5147 }
5148 | %empty
5149 {
5150 $$ = 0;
5151 }
5152 ;
5154 opt_context
5155 : IDL_CONTEXT
5156 {
5157 idl_global->set_parse_state (IDL_GlobalData::PS_OpContextSeen);
5158 }
5159 '('
5160 {
5161 idl_global->set_parse_state (IDL_GlobalData::PS_OpContextSqSeen);
5162 }
5163 at_least_one_string_literal
5164 ')'
5165 {
5166 idl_global->set_parse_state (IDL_GlobalData::PS_OpContextQsSeen);
5167 $$ = $5;
5168 }
5169 | %empty
5170 {
5171 $$ = 0;
5172 }
5173 ;
5175 at_least_one_string_literal :
5176 IDL_STRING_LITERAL string_literals
5177 {
5178 ACE_NEW_RETURN ($<slval>$,
5179 UTL_StrList ($1,
5180 $2),
5181 1);
5182 }
5183 ;
5185 string_literals
5186 : string_literals
5187 ','
5188 {
5189 idl_global->set_parse_state (IDL_GlobalData::PS_OpContextCommaSeen);
5190 }
5191 IDL_STRING_LITERAL
5192 {
5193 UTL_StrList *sl = 0;
5194 ACE_NEW_RETURN (sl,
5195 UTL_StrList ($4,
5196 0),
5197 1);
5199 if ($1 == 0)
5200 {
5201 $<slval>$ = sl;
5202 }
5203 else
5204 {
5205 $1->nconc (sl);
5206 $<slval>$ = $1;
5207 }
5208 }
5209 | %empty
5210 {
5211 $$ = 0;
5212 }
5213 ;
5215 typeid_dcl
5216 : IDL_TYPEID scoped_name IDL_STRING_LITERAL
5217 {
5218 UTL_Scope *s = idl_global->scopes ().top_non_null ();
5219 AST_Decl *d =
5220 s->lookup_by_name ($2);
5222 if (d == 0)
5223 {
5224 idl_global->err ()->lookup_error ($2);
5225 }
5226 else
5227 {
5228 d->set_id_with_typeid (
5229 $3->get_string ()
5230 );
5231 }
5233 $2->destroy ();
5234 delete $2;
5235 $2 = 0;
5237 $3->destroy ();
5238 delete $3;
5239 $3 = 0;
5241 $$ = 0;
5242 }
5243 ;
5245 typeprefix_dcl
5246 : IDL_TYPEPREFIX scoped_name IDL_STRING_LITERAL
5247 {
5248 UTL_Scope *s = idl_global->scopes ().top_non_null ();
5249 AST_Decl *d = ScopeAsDecl (s);
5251 // If we are in a module, we want to avoid a lookup unless the
5252 // typeprefix is to be applied to some other scope, since we
5253 // might get a previous opening of the module, and the prefix
5254 // of this opening would never get checked or set.
5255 if (d->name ()->compare ($2) != 0)
5256 {
5257 d =
5258 s->lookup_by_name ($2);
5259 }
5261 if (d == 0)
5262 {
5263 idl_global->err ()->lookup_error ($2);
5264 }
5265 else
5266 {
5267 d->set_prefix_with_typeprefix (
5268 $3->get_string ()
5269 );
5270 }
5272 $2->destroy ();
5273 delete $2;
5274 $2 = 0;
5276 $3->destroy ();
5277 delete $3;
5278 $3 = 0;
5280 $$ = 0;
5281 }
5282 ;
5284 component
5285 : component_decl
5286 | component_forward_decl
5287 ;
5289 component_forward_decl :
5290 IDL_COMPONENT
5291 defining_id
5292 {
5293 UTL_Scope *s = idl_global->scopes ().top_non_null ();
5294 UTL_ScopedName n ($2,
5295 0);
5296 AST_ComponentFwd *f = 0;
5297 idl_global->set_parse_state (
5298 IDL_GlobalData::PS_ComponentForwardSeen
5299 );
5301 /*
5302 * Create a node representing a forward declaration of a
5303 * component. Store it in the enclosing scope.
5304 */
5305 if (s != 0)
5306 {
5307 f = idl_global->gen ()->create_component_fwd (&n);
5308 (void) s->fe_add_component_fwd (f);
5309 }
5311 $2->destroy ();
5312 delete $2;
5313 $2 = 0;
5315 $$ = 0;
5316 }
5317 ;
5319 component_decl :
5320 component_header
5321 {
5322 FE_ComponentHeader *&component_header = $1;
5323 UTL_Scope *scope = idl_global->scopes ().top_non_null ();
5324 AST_Component *component = 0;
5326 /*
5327 * Make a new component node and add it to the enclosing scope.
5328 */
5329 if (scope && component_header)
5330 {
5331 component = idl_global->gen ()->create_component (
5332 component_header->name (),
5333 component_header->base_component (),
5334 component_header->supports (),
5335 component_header->n_supports (),
5336 component_header->supports_flat (),
5337 component_header->n_supports_flat ());
5338 AST_Interface *component_as_interface =
5339 dynamic_cast<AST_Interface *> (component);
5340 AST_Interface::fwd_redefinition_helper (
5341 component_as_interface, scope);
5342 component = dynamic_cast<AST_Component *> (component_as_interface);
5344 /*
5345 * Add the component to its definition scope.
5346 */
5347 scope->fe_add_component (component);
5349 // This FE_ComponentHeader class isn't destroyed with the AST.
5350 component_header->destroy ();
5351 delete component_header;
5352 component_header = 0;
5353 }
5355 /*
5356 * Push it on the scope stack.
5357 */
5358 idl_global->scopes ().push (component);
5360 $<dcval>$ = component;
5361 }
5362 '{'
5363 {
5364 idl_global->set_parse_state (IDL_GlobalData::PS_ComponentSqSeen);
5365 }
5366 component_exports
5367 {
5368 idl_global->set_parse_state (IDL_GlobalData::PS_ComponentBodySeen);
5369 }
5370 '}'
5371 {
5372 idl_global->set_parse_state (IDL_GlobalData::PS_ComponentQsSeen);
5374 /*
5375 * Done with this component - pop it off the scopes stack.
5376 */
5377 idl_global->scopes ().pop ();
5379 $$ = $<dcval>2;
5380 }
5381 ;
5383 component_header :
5384 IDL_COMPONENT
5385 defining_id
5386 {
5387 idl_global->set_parse_state (IDL_GlobalData::PS_ComponentIDSeen);
5388 }
5389 component_inheritance_spec
5390 {
5391 idl_global->set_parse_state (IDL_GlobalData::PS_InheritSpecSeen);
5392 }
5393 supports_spec
5394 {
5395 idl_global->set_parse_state (IDL_GlobalData::PS_SupportSpecSeen);
5397 /*
5398 * Create an AST representation of the information in the header
5399 * part of a component.
5400 */
5401 UTL_ScopedName *n = 0;
5402 ACE_NEW_RETURN (n,
5403 UTL_ScopedName ($2,
5404 0),
5405 1);
5406 ACE_NEW_RETURN ($<chval>$,
5407 FE_ComponentHeader (n,
5408 $4,
5409 $6,
5410 false),
5411 1);
5413 if (0 != $6)
5414 {
5415 $6->destroy ();
5416 delete $6;
5417 $6 = 0;
5418 }
5420 if (0 != $4)
5421 {
5422 $4->destroy ();
5423 delete $4;
5424 $4 = 0;
5425 }
5426 }
5427 ;
5429 component_inheritance_spec
5430 : ':'
5431 {
5432 idl_global->set_parse_state (IDL_GlobalData::PS_InheritColonSeen);
5433 }
5434 scoped_name
5435 {
5436 $<idlist>$ = $3;
5437 }
5438 | %empty
5439 {
5440 $$ = 0;
5441 }
5442 ;
5444 component_exports
5445 : component_exports at_least_one_annotation component_export
5446 {
5447 AST_Annotation_Appls *&annotations = $2;
5448 AST_Decl *&node = $3;
5449 if (node)
5450 {
5451 node->annotation_appls (*annotations);
5452 }
5453 else
5454 {
5455 idl_global->err ()-> unsupported_warning (
5456 "Annotating this is not supported");
5457 }
5458 delete annotations;
5459 }
5460 | component_exports component_export
5461 | %empty
5462 ;
5464 component_export
5465 : provides_decl
5466 {
5467 idl_global->set_parse_state (IDL_GlobalData::PS_ProvidesDeclSeen);
5468 }
5469 ';'
5470 {
5471 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
5472 $$ = $1;
5473 }
5474 | uses_decl
5475 {
5476 idl_global->set_parse_state (IDL_GlobalData::PS_UsesDeclSeen);
5477 }
5478 ';'
5479 {
5480 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
5481 $$ = $1;
5482 }
5483 | emits_decl
5484 {
5485 idl_global->set_parse_state (IDL_GlobalData::PS_EmitsDeclSeen);
5486 }
5487 ';'
5488 {
5489 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
5490 $$ = $1;
5491 }
5492 | publishes_decl
5493 {
5494 idl_global->set_parse_state (IDL_GlobalData::PS_PublishesDeclSeen);
5495 }
5496 ';'
5497 {
5498 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
5499 $$ = $1;
5500 }
5501 | consumes_decl
5502 {
5503 idl_global->set_parse_state (IDL_GlobalData::PS_ConsumesDeclSeen);
5504 }
5505 ';'
5506 {
5507 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
5508 $$ = $1;
5509 }
5510 | attribute
5511 {
5512 idl_global->set_parse_state (IDL_GlobalData::PS_AttrDeclSeen);
5513 }
5514 ';'
5515 {
5516 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
5517 $$ = $1;
5518 }
5519 | extended_port_decl
5520 {
5521 idl_global->set_parse_state (IDL_GlobalData::PS_ExtendedPortDeclSeen);
5522 }
5523 ';'
5524 {
5525 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
5526 $$ = $1;
5527 }
5528 ;
5530 provides_decl : IDL_PROVIDES interface_type id
5531 {
5532 UTL_Scope *s = idl_global->scopes ().top_non_null ();
5533 bool so_far_so_good = true;
5534 AST_Decl::NodeType nt = AST_Decl::NT_type;
5535 AST_Param_Holder *ph = 0;
5537 AST_Decl *d =
5538 s->lookup_by_name ($2, true, false);
5540 if (d == 0)
5541 {
5542 idl_global->err ()->lookup_error ($2);
5543 so_far_so_good = false;
5544 }
5545 else
5546 {
5547 int compare = 0;
5548 nt = d->node_type ();
5550 switch (nt)
5551 {
5552 case AST_Decl::NT_interface:
5553 break;
5554 case AST_Decl::NT_param_holder:
5555 ph = dynamic_cast<AST_Param_Holder*> (d);
5556 nt = ph->info ()->type_;
5558 if (nt != AST_Decl::NT_type
5559 && nt != AST_Decl::NT_interface)
5560 {
5561 idl_global->err ()->mismatched_template_param (
5562 ph->info ()->name_.c_str ());
5564 so_far_so_good = false;
5565 }
5567 break;
5568 case AST_Decl::NT_pre_defined:
5569 // Nothing else but CORBA::Object can have
5570 // this identifier.
5571 compare =
5572 ACE_OS::strcmp (d->local_name ()->get_string (),
5573 "Object");
5575 // Simple provides port must use IDL interface
5576 // or CORBA::Object.
5577 if (compare != 0)
5578 {
5579 idl_global->err ()->interface_expected (d);
5580 so_far_so_good = false;
5581 }
5583 break;
5584 default:
5585 idl_global->err ()->interface_expected (d);
5586 so_far_so_good = false;
5587 break;
5588 }
5589 }
5591 AST_Provides *provides = 0;
5593 if (so_far_so_good)
5594 {
5595 AST_Type *port_interface_type =
5596 dynamic_cast<AST_Type*> (d);
5598 // Strip off _cxx_, if any, for port name.
5599 FE_Utils::original_local_name ($3);
5601 UTL_ScopedName sn ($3,
5602 0);
5604 provides = idl_global->gen ()->create_provides (
5605 &sn, port_interface_type);
5607 (void) s->fe_add_provides (provides);
5608 }
5610 $2->destroy ();
5611 delete $2;
5612 $2 = 0;
5614 $3->destroy ();
5615 delete $3;
5616 $3 = 0;
5618 $$ = dynamic_cast<AST_Decl *> (provides);
5619 }
5620 ;
5622 interface_type
5623 : scoped_name
5624 {
5625 // Lookups and checking are done where the 'interface_type'
5626 // token is used, in 'provides_decl' and 'uses_decl'.
5627 $$ = $1;
5628 }
5629 | IDL_OBJECT
5630 {
5631 Identifier *corba_id = 0;
5633 ACE_NEW_RETURN (corba_id,
5634 Identifier ("Object"),
5635 1);
5637 UTL_IdList *conc_name = 0;
5638 ACE_NEW_RETURN (conc_name,
5639 UTL_IdList (corba_id,
5640 0),
5641 1);
5643 ACE_NEW_RETURN (corba_id,
5644 Identifier ("CORBA"),
5645 1);
5647 ACE_NEW_RETURN ($<idlist>$,
5648 UTL_IdList (corba_id,
5649 conc_name),
5650 1);
5651 }
5652 ;
5654 uses_decl : uses_opt_multiple interface_type id
5655 {
5656 UTL_Scope *s = idl_global->scopes ().top_non_null ();
5657 bool so_far_so_good = true;
5658 AST_Decl::NodeType nt = AST_Decl::NT_type;
5659 AST_Param_Holder *ph = 0;
5661 AST_Decl *d =
5662 s->lookup_by_name ($2, true, false);
5664 if (d == 0)
5665 {
5666 idl_global->err ()->lookup_error ($2);
5667 so_far_so_good = false;
5668 }
5669 else
5670 {
5671 int compare = 0;
5672 nt = d->node_type ();
5674 switch (nt)
5675 {
5676 case AST_Decl::NT_interface:
5677 break;
5678 case AST_Decl::NT_param_holder:
5679 ph = dynamic_cast<AST_Param_Holder*> (d);
5680 nt = ph->info ()->type_;
5682 if (nt != AST_Decl::NT_type
5683 && nt != AST_Decl::NT_interface)
5684 {
5685 idl_global->err ()->mismatched_template_param (
5686 ph->info ()->name_.c_str ());
5688 so_far_so_good = false;
5689 }
5691 break;
5692 case AST_Decl::NT_pre_defined:
5693 // Nothing else but CORBA::Object can have
5694 // this identifier.
5695 compare =
5696 ACE_OS::strcmp (d->local_name ()->get_string (),
5697 "Object");
5699 // Simple provides port must use IDL interface
5700 // or CORBA::Object.
5701 if (compare != 0)
5702 {
5703 idl_global->err ()->interface_expected (d);
5704 so_far_so_good = false;
5705 }
5707 break;
5708 default:
5709 idl_global->err ()->interface_expected (d);
5710 so_far_so_good = false;
5711 break;
5712 }
5713 }
5715 AST_Uses *uses = 0;
5717 if (so_far_so_good)
5718 {
5719 AST_Type *port_interface_type =
5720 dynamic_cast<AST_Type*> (d);
5722 // Strip off _cxx_, if any, for port name.
5723 FE_Utils::original_local_name ($3);
5725 UTL_ScopedName sn ($3,
5726 0);
5728 uses = idl_global->gen ()->create_uses (
5729 &sn, port_interface_type, $1);
5730 s->fe_add_uses (uses);
5732 AST_Component *c =
5733 dynamic_cast<AST_Component*> (s);
5735 if (c != 0
5736 && uses->is_multiple ()
5737 && !idl_global->using_ifr_backend ()
5738 && !idl_global->ignore_idl3 ()
5739 && nt != AST_Decl::NT_param_holder)
5740 {
5741 // These datatypes must be created in the
5742 // front end so they can be looked up
5743 // when compiling the generated executor IDL.
5744 FE_Utils::create_uses_multiple_stuff (c, uses);
5745 }
5746 }
5748 $2->destroy ();
5749 delete $2;
5750 $2 = 0;
5752 $3->destroy ();
5753 delete $3;
5754 $3 = 0;
5756 $$ = uses;
5757 }
5758 ;
5760 uses_opt_multiple
5761 : IDL_USES opt_multiple
5762 {
5763 // We use this extra rule here to use in both uses_decl and
5764 // extended_uses_decl, so the LALR(1) parser can avoid conflicts.
5765 $$ = $2;
5766 }
5767 ;
5769 opt_multiple
5770 : IDL_MULTIPLE
5771 {
5772 $$ = true;
5773 }
5774 | %empty
5775 {
5776 $$ = false;
5777 }
5778 ;
5780 emits_decl
5781 : IDL_EMITS scoped_name id
5782 {
5783 UTL_Scope *s = idl_global->scopes ().top_non_null ();
5784 bool so_far_so_good = true;
5785 AST_Decl::NodeType nt = AST_Decl::NT_type;
5786 AST_Param_Holder *ph = 0;
5788 AST_Decl *d =
5789 s->lookup_by_name ($2, true, false);
5791 if (0 == d)
5792 {
5793 idl_global->err ()->lookup_error ($2);
5794 so_far_so_good = false;
5795 }
5796 else
5797 {
5798 nt = d->node_type ();
5800 switch (nt)
5801 {
5802 case AST_Decl::NT_eventtype:
5803 break;
5804 case AST_Decl::NT_param_holder:
5805 ph = dynamic_cast<AST_Param_Holder*> (d);
5806 nt = ph->info ()->type_;
5808 if (nt != AST_Decl::NT_type
5809 && nt != AST_Decl::NT_eventtype)
5810 {
5811 idl_global->err ()->mismatched_template_param (
5812 ph->info ()->name_.c_str ());
5814 so_far_so_good = false;
5815 }
5817 break;
5818 default:
5819 idl_global->err ()->eventtype_expected (d);
5820 so_far_so_good = false;
5821 break;
5822 }
5823 }
5825 AST_Emits *e = 0;
5827 if (so_far_so_good)
5828 {
5829 AST_Type *event_type =
5830 dynamic_cast<AST_Type*> (d);
5832 // Strip off _cxx_, if any, for port name.
5833 FE_Utils::original_local_name ($3);
5835 UTL_ScopedName sn ($3,
5836 0);
5838 e = idl_global->gen ()->create_emits (&sn, event_type);
5840 (void) s->fe_add_emits (e);
5841 }
5843 $2->destroy ();
5844 delete $2;
5845 $2 = 0;
5847 $3->destroy ();
5848 delete $3;
5849 $3 = 0;
5851 $$ = e;
5852 }
5853 ;
5855 publishes_decl
5856 : IDL_PUBLISHES scoped_name id
5857 {
5858 UTL_Scope *s = idl_global->scopes ().top_non_null ();
5859 bool so_far_so_good = true;
5860 AST_Decl::NodeType nt = AST_Decl::NT_type;
5861 AST_Param_Holder *ph = 0;
5863 AST_Decl *d =
5864 s->lookup_by_name ($2, true, false);
5866 if (0 == d)
5867 {
5868 idl_global->err ()->lookup_error ($2);
5869 so_far_so_good = false;
5870 }
5871 else
5872 {
5873 nt = d->node_type ();
5875 switch (nt)
5876 {
5877 case AST_Decl::NT_eventtype:
5878 break;
5879 case AST_Decl::NT_param_holder:
5880 ph = dynamic_cast<AST_Param_Holder*> (d);
5881 nt = ph->info ()->type_;
5883 if (nt != AST_Decl::NT_type
5884 && nt != AST_Decl::NT_eventtype)
5885 {
5886 idl_global->err ()->mismatched_template_param (
5887 ph->info ()->name_.c_str ());
5889 so_far_so_good = false;
5890 }
5892 break;
5893 default:
5894 idl_global->err ()->eventtype_expected (d);
5895 so_far_so_good = false;
5896 break;
5897 }
5898 }
5900 AST_Publishes *p = 0;
5902 if (so_far_so_good)
5903 {
5904 AST_Type *event_type =
5905 dynamic_cast<AST_Type*> (d);
5907 // Strip off _cxx_, if any, for port name.
5908 FE_Utils::original_local_name ($3);
5910 UTL_ScopedName sn ($3, 0);
5911 p = idl_global->gen ()->create_publishes (&sn, event_type);
5912 s->fe_add_publishes (p);
5913 }
5915 $2->destroy ();
5916 delete $2;
5917 $2 = 0;
5919 $3->destroy ();
5920 delete $3;
5921 $3 = 0;
5923 $$ = p;
5924 }
5925 ;
5927 consumes_decl
5928 : IDL_CONSUMES scoped_name id
5929 {
5930 UTL_Scope *s = idl_global->scopes ().top_non_null ();
5931 bool so_far_so_good = true;
5932 AST_Decl::NodeType nt = AST_Decl::NT_type;
5933 AST_Param_Holder *ph = 0;
5935 AST_Decl *d =
5936 s->lookup_by_name ($2, true, false);
5938 if (0 == d)
5939 {
5940 idl_global->err ()->lookup_error ($2);
5941 so_far_so_good = false;
5942 }
5943 else
5944 {
5945 nt = d->node_type ();
5947 switch (nt)
5948 {
5949 case AST_Decl::NT_eventtype:
5950 break;
5951 case AST_Decl::NT_param_holder:
5952 ph = dynamic_cast<AST_Param_Holder*> (d);
5953 nt = ph->info ()->type_;
5955 if (nt != AST_Decl::NT_type
5956 && nt != AST_Decl::NT_eventtype)
5957 {
5958 idl_global->err ()->mismatched_template_param (
5959 ph->info ()->name_.c_str ());
5961 so_far_so_good = false;
5962 }
5964 break;
5965 default:
5966 idl_global->err ()->eventtype_expected (d);
5967 so_far_so_good = false;
5968 break;
5969 }
5970 }
5972 AST_Consumes *c = 0;
5974 if (so_far_so_good)
5975 {
5976 AST_Type *event_type =
5977 dynamic_cast<AST_Type*> (d);
5979 // Strip off _cxx_, if any, for port name.
5980 FE_Utils::original_local_name ($3);
5982 UTL_ScopedName sn ($3,
5983 0);
5985 c = idl_global->gen ()->create_consumes (&sn, event_type);
5987 (void) s->fe_add_consumes (c);
5988 }
5990 $2->destroy ();
5991 delete $2;
5992 $2 = 0;
5994 $3->destroy ();
5995 delete $3;
5996 $3 = 0;
5998 $$ = c;
5999 }
6000 ;
6002 home_decl
6003 : home_header
6004 {
6005 UTL_Scope *s = idl_global->scopes ().top_non_null ();
6006 AST_Home *h = 0;
6008 /*
6009 * Make a new home node and add it to the enclosing scope.
6010 */
6011 if (s != 0 && $1 != 0)
6012 {
6013 h =
6014 idl_global->gen ()->create_home (
6015 $1->name (),
6016 $1->base_home (),
6017 $1->managed_component (),
6018 $1->primary_key (),
6019 $1->supports (),
6020 $1->n_supports (),
6021 $1->supports_flat (),
6022 $1->n_supports_flat ()
6023 );
6024 /*
6025 * Add the home to its definition scope.
6026 */
6027 (void) s->fe_add_home (h);
6029 // This FE_HomeHeader class isn't destroyed with the AST.
6030 $1->destroy ();
6031 delete $1;
6032 $1 = 0;
6033 }
6035 /*
6036 * Push it on the scope stack.
6037 */
6038 idl_global->scopes ().push (h);
6039 }
6040 home_body
6041 {
6042 /*
6043 * Done with this component - pop it off the scopes stack.
6044 */
6045 idl_global->scopes ().pop ();
6047 $$ = 0;
6048 }
6049 ;
6051 home_header
6052 : IDL_HOME
6053 {
6054 idl_global->set_parse_state (IDL_GlobalData::PS_HomeSeen);
6055 }
6056 defining_id
6057 {
6058 idl_global->set_parse_state (IDL_GlobalData::PS_HomeIDSeen);
6059 }
6060 home_inheritance_spec
6061 {
6062 idl_global->set_parse_state (IDL_GlobalData::PS_InheritSpecSeen);
6063 }
6064 supports_spec
6065 {
6066 idl_global->set_parse_state (IDL_GlobalData::PS_SupportSpecSeen);
6067 }
6068 IDL_MANAGES
6069 {
6070 idl_global->set_parse_state (IDL_GlobalData::PS_ManagesSeen);
6071 }
6072 scoped_name
6073 {
6074 idl_global->set_parse_state (IDL_GlobalData::PS_ManagesIDSeen);
6075 }
6076 primary_key_spec
6077 {
6078 idl_global->set_parse_state (IDL_GlobalData::PS_PrimaryKeySpecSeen);
6080 /*
6081 * Create an AST representation of the information in the header
6082 * part of a component home.
6083 */
6084 UTL_ScopedName *n = 0;
6085 ACE_NEW_RETURN (n,
6086 UTL_ScopedName ($3, 0),
6087 1);
6089 ACE_NEW_RETURN ($<hhval>$,
6090 FE_HomeHeader (n,
6091 $5,
6092 $7,
6093 $11,
6094 $13),
6095 1);
6097 $11->destroy ();
6098 delete $11;
6099 $11 = 0;
6101 if (0 != $5)
6102 {
6103 $5->destroy ();
6104 delete $5;
6105 $5 = 0;
6106 }
6108 if (0 != $13)
6109 {
6110 $13->destroy ();
6111 delete $13;
6112 $13 = 0;
6113 }
6115 if (0 != $7)
6116 {
6117 $7->destroy ();
6118 delete $7;
6119 $7 = 0;
6120 }
6121 }
6122 ;
6124 home_inheritance_spec
6125 : ':'
6126 {
6127 idl_global->set_parse_state (IDL_GlobalData::PS_InheritColonSeen);
6128 }
6129 scoped_name
6130 {
6131 $<idlist>$ = $3;
6132 }
6133 | %empty
6134 {
6135 $$ = 0;
6136 }
6137 ;
6139 primary_key_spec
6140 : IDL_PRIMARYKEY
6141 scoped_name
6142 {
6143 $$ = $2;
6144 }
6145 | %empty
6146 {
6147 $$ = 0;
6148 }
6149 ;
6151 home_body :
6152 '{'
6153 {
6154 idl_global->set_parse_state (IDL_GlobalData::PS_HomeSqSeen);
6155 }
6156 home_exports
6157 {
6158 idl_global->set_parse_state (IDL_GlobalData::PS_HomeBodySeen);
6159 }
6160 '}'
6161 {
6162 idl_global->set_parse_state (IDL_GlobalData::PS_HomeQsSeen);
6163 }
6164 ;
6166 home_exports
6167 : home_exports home_export
6168 | %empty
6169 ;
6171 home_export
6172 : export
6173 | factory_decl
6174 {
6175 idl_global->set_parse_state (IDL_GlobalData::PS_FactoryDeclSeen);
6176 }
6177 ';'
6178 {
6179 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
6180 }
6181 | finder_decl
6182 {
6183 idl_global->set_parse_state (IDL_GlobalData::PS_FinderDeclSeen);
6184 }
6185 ';'
6186 {
6187 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
6188 }
6189 ;
6191 factory_decl :
6192 IDL_FACTORY
6193 defining_id
6194 {
6195 UTL_Scope *s = idl_global->scopes ().top_non_null ();
6196 UTL_ScopedName n ($2,
6197 0);
6198 idl_global->set_parse_state (IDL_GlobalData::PS_OpIDSeen);
6200 /*
6201 * Create a node representing a factory operation
6202 * and add it to the enclosing scope.
6203 */
6204 AST_Factory *f = idl_global->gen ()->create_factory (&n);
6205 (void) s->fe_add_factory (f);
6207 $2->destroy ();
6208 delete $2;
6209 $2 = 0;
6211 /*
6212 * Push the factory scope onto the scopes stack.
6213 */
6214 idl_global->scopes ().push (f);
6215 }
6216 init_parameter_list
6217 {
6218 idl_global->set_parse_state (IDL_GlobalData::PS_OpParsCompleted);
6219 }
6220 opt_raises
6221 {
6222 UTL_Scope *s = idl_global->scopes ().top_non_null ();
6223 idl_global->set_parse_state (IDL_GlobalData::PS_OpRaiseCompleted);
6225 /*
6226 * Add exceptions and context to the factory.
6227 */
6228 if ($6 != 0)
6229 {
6230 (void) s->fe_add_exceptions ($6);
6231 }
6233 /*
6234 * Done with this factory. Pop its scope from the scopes stack.
6235 */
6236 idl_global->scopes ().pop ();
6237 }
6238 ;
6240 finder_decl :
6241 IDL_FINDER
6242 defining_id
6243 {
6244 UTL_Scope *s = idl_global->scopes ().top_non_null ();
6245 UTL_ScopedName n ($2,
6246 0);
6248 idl_global->set_parse_state (IDL_GlobalData::PS_OpIDSeen);
6250 /*
6251 * Create a node representing a home finder
6252 * and add it to the enclosing scope.
6253 */
6254 AST_Finder *f =
6255 idl_global->gen ()->create_finder (&n);
6257 (void) s->fe_add_finder (f);
6260 $2->destroy ();
6261 delete $2;
6262 $2 = 0;
6264 /*
6265 * Push the operation scope onto the scopes stack.
6266 */
6267 idl_global->scopes ().push (f);
6268 }
6269 init_parameter_list
6270 {
6271 idl_global->set_parse_state (IDL_GlobalData::PS_OpParsCompleted);
6272 }
6273 opt_raises
6274 {
6275 UTL_Scope *s = idl_global->scopes ().top_non_null ();
6276 idl_global->set_parse_state (IDL_GlobalData::PS_OpRaiseCompleted);
6278 /*
6279 * Add exceptions and context to the finder.
6280 */
6281 if ($6 != 0)
6282 {
6283 (void) s->fe_add_exceptions ($6);
6284 }
6286 /*
6287 * Done with this operation. Pop its scope from the scopes stack.
6288 */
6289 idl_global->scopes ().pop ();
6290 }
6291 ;
6293 event
6294 : event_decl
6295 | event_abs_decl
6296 | event_forward_decl
6297 ;
6299 event_forward_decl
6300 : event_abs_forward_decl
6301 | event_concrete_forward_decl
6302 ;
6304 event_concrete_forward_decl :
6305 IDL_EVENTTYPE
6306 defining_id
6307 {
6308 UTL_Scope *s = idl_global->scopes ().top_non_null ();
6309 UTL_ScopedName n ($2,
6310 0);
6311 AST_EventTypeFwd *f = 0;
6312 idl_global->set_parse_state (IDL_GlobalData::PS_EventTypeForwardSeen);
6314 /*
6315 * Create a node representing a forward declaration of an
6316 * eventtype. Store it in the enclosing scope
6317 */
6318 if (s != 0)
6319 {
6320 f = idl_global->gen ()->create_eventtype_fwd (&n,
6321 false);
6322 (void) s->fe_add_valuetype_fwd (f);
6323 }
6325 $2->destroy ();
6326 delete $2;
6327 $2 = 0;
6329 $$ = 0;
6330 }
6331 ;
6333 event_abs_forward_decl :
6334 IDL_ABSTRACT
6335 IDL_EVENTTYPE
6336 defining_id
6337 {
6338 UTL_Scope *s = idl_global->scopes ().top_non_null ();
6339 UTL_ScopedName n ($3,
6340 0);
6341 AST_EventTypeFwd *f = 0;
6342 idl_global->set_parse_state (IDL_GlobalData::PS_EventTypeForwardSeen);
6344 /*
6345 * Create a node representing a forward declaration of an
6346 * eventtype. Store it in the enclosing scope
6347 */
6348 if (s != 0)
6349 {
6350 f = idl_global->gen ()->create_eventtype_fwd (&n,
6351 true);
6352 (void) s->fe_add_valuetype_fwd (f);
6353 }
6355 $3->destroy ();
6356 delete $3;
6357 $3 = 0;
6359 $$ = 0;
6360 }
6361 ;
6363 event_abs_decl :
6364 event_abs_header
6365 event_rest_of_header
6366 {
6367 UTL_Scope *s = idl_global->scopes ().top_non_null ();
6368 AST_EventType *e = 0;
6369 AST_Interface *i = 0;
6371 if (s != 0 && $1 != 0)
6372 {
6373 UTL_ScopedName sn ($1,
6374 0);
6375 e =
6376 idl_global->gen ()->create_eventtype (
6377 &sn,
6378 $2->inherits (),
6379 $2->n_inherits (),
6380 $2->inherits_concrete (),
6381 $2->inherits_flat (),
6382 $2->n_inherits_flat (),
6383 $2->supports (),
6384 $2->n_supports (),
6385 $2->supports_concrete (),
6386 true,
6387 false,
6388 false
6389 );
6390 i = dynamic_cast<AST_Interface*> (e);
6391 AST_Interface::fwd_redefinition_helper (i,
6392 s);
6393 /*
6394 * Add the eventetype to its definition scope
6395 */
6396 e = dynamic_cast<AST_EventType*> (i);
6397 (void) s->fe_add_eventtype (e);
6398 }
6400 /*
6401 * Push it on the scope stack.
6402 */
6403 idl_global->scopes ().push (e);
6405 $1->destroy ();
6406 delete $1;
6407 $1 = 0;
6408 }
6409 '{'
6410 {
6411 idl_global->set_parse_state (IDL_GlobalData::PS_EventTypeSqSeen);
6412 }
6413 exports
6414 {
6415 idl_global->set_parse_state (IDL_GlobalData::PS_EventTypeBodySeen);
6416 }
6417 '}'
6418 {
6419 idl_global->set_parse_state (IDL_GlobalData::PS_EventTypeQsSeen);
6421 /*
6422 * Done with this eventtype - pop it off the scopes stack.
6423 */
6424 idl_global->scopes ().pop ();
6426 $$ = 0;
6427 }
6428 ;
6430 event_abs_header :
6431 IDL_ABSTRACT
6432 IDL_EVENTTYPE
6433 defining_id
6434 {
6435 $$ = $3;
6436 }
6437 ;
6439 event_custom_header :
6440 IDL_CUSTOM
6441 IDL_EVENTTYPE
6442 defining_id
6443 {
6444 idl_global->set_parse_state (IDL_GlobalData::PS_EventTypeIDSeen);
6446 ACE_DEBUG ((LM_DEBUG,
6447 ACE_TEXT ("error in %C line %d\n"),
6448 idl_global->filename ()->get_string (),
6449 idl_global->lineno ()));
6450 ACE_DEBUG ((LM_DEBUG,
6451 ACE_TEXT ("Sorry, I (TAO_IDL) can't handle")
6452 ACE_TEXT (" custom yet\n")));
6453 $$ = 0;
6454 }
6455 ;
6457 event_plain_header :
6458 IDL_EVENTTYPE
6459 defining_id
6460 {
6461 idl_global->set_parse_state (IDL_GlobalData::PS_EventTypeIDSeen);
6463 $$ = $2;
6464 }
6465 ;
6467 event_rest_of_header :
6468 inheritance_spec
6469 {
6470 idl_global->set_parse_state (IDL_GlobalData::PS_InheritSpecSeen);
6471 }
6472 supports_spec
6473 {
6474 idl_global->set_parse_state (IDL_GlobalData::PS_SupportSpecSeen);
6476 ACE_NEW_RETURN ($<vhval>$,
6477 FE_OBVHeader (
6478 0,
6479 $1,
6480 $3,
6481 $1
6482 ? $1->truncatable ()
6483 : false,
6484 true),
6485 1);
6487 if (0 != $3)
6488 {
6489 $3->destroy ();
6490 delete $3;
6491 $3 = 0;
6492 }
6494 if (0 != $1)
6495 {
6496 $1->destroy ();
6497 delete $1;
6498 $1 = 0;
6499 }
6500 }
6501 ;
6503 event_decl :
6504 event_header
6505 event_rest_of_header
6506 {
6507 UTL_Scope *scope = idl_global->scopes ().top_non_null ();
6508 Identifier *&event_id = $1;
6509 FE_OBVHeader *&event_header = $2;
6510 AST_EventType *eventtype = 0;
6512 if (scope && event_header)
6513 {
6514 // We create the scoped name here instead of with the
6515 // FE_OBVHeader because there is a token for it only here.
6516 UTL_ScopedName sn (event_id, 0);
6517 eventtype = idl_global->gen ()->create_eventtype (
6518 &sn,
6519 event_header->inherits (),
6520 event_header->n_inherits (),
6521 event_header->inherits_concrete (),
6522 event_header->inherits_flat (),
6523 event_header->n_inherits_flat (),
6524 event_header->supports (),
6525 event_header->n_supports (),
6526 event_header->supports_concrete (),
6527 false,
6528 event_header->truncatable (),
6529 false);
6530 AST_Interface *eventtype_as_interface =
6531 dynamic_cast<AST_Interface *> (eventtype);
6532 AST_Interface::fwd_redefinition_helper (
6533 eventtype_as_interface, scope);
6534 eventtype = dynamic_cast<AST_EventType *> (eventtype_as_interface);
6536 /*
6537 * Add the eventetype to its definition scope
6538 */
6539 scope->fe_add_eventtype (eventtype);
6541 // FE_OBVHeader is not automatically destroyed in the AST
6542 event_header->destroy ();
6543 delete event_header;
6544 event_header = 0;
6546 sn.destroy ();
6547 }
6549 /*
6550 * Push it on the scope stack.
6551 */
6552 idl_global->scopes ().push (eventtype);
6554 $<dcval>$ = eventtype;
6555 }
6556 '{'
6557 {
6558 idl_global->set_parse_state (IDL_GlobalData::PS_EventTypeSqSeen);
6559 }
6560 value_elements
6561 {
6562 idl_global->set_parse_state (IDL_GlobalData::PS_EventTypeBodySeen);
6563 }
6564 '}'
6565 {
6566 idl_global->set_parse_state (IDL_GlobalData::PS_EventTypeQsSeen);
6568 /*
6569 * Done with this eventtype - pop it off the scopes stack.
6570 */
6571 idl_global->scopes ().pop ();
6573 $$ = $<dcval>3;
6574 }
6575 ;
6577 event_header
6578 : event_custom_header
6579 {
6580 $$ = $1;
6581 }
6582 | event_plain_header
6583 {
6584 $$ = $1;
6585 }
6586 ;
6588 formal_parameter_type
6589 : IDL_TYPENAME
6590 {
6591 $<ntval>$ = AST_Decl::NT_type;
6592 }
6593 | IDL_STRUCT
6594 {
6595 $<ntval>$ = AST_Decl::NT_struct;
6596 }
6597 | IDL_UNION
6598 {
6599 $<ntval>$ = AST_Decl::NT_union;
6600 }
6601 | IDL_EVENTTYPE
6602 {
6603 $<ntval>$ = AST_Decl::NT_eventtype;
6604 }
6605 | IDL_SEQUENCE
6606 {
6607 $<ntval>$ = AST_Decl::NT_sequence;
6608 }
6609 | IDL_INTERFACE
6610 {
6611 $<ntval>$ = AST_Decl::NT_interface;
6612 }
6613 | IDL_VALUETYPE
6614 {
6615 $<ntval>$ = AST_Decl::NT_valuetype;
6616 }
6617 | IDL_ENUM
6618 {
6619 $<ntval>$ = AST_Decl::NT_enum;
6620 }
6621 | IDL_EXCEPTION
6622 {
6623 $<ntval>$ = AST_Decl::NT_except;
6624 }
6625 | IDL_CONST const_type
6626 {
6627 $<ntval>$ = AST_Decl::NT_const;
6628 t_param_const_type = $2;
6629 }
6630 ;
6632 at_least_one_formal_parameter
6633 : formal_parameter formal_parameters
6634 {
6635 if ($2 == 0)
6636 {
6637 ACE_NEW_RETURN ($2, FE_Utils::T_PARAMLIST_INFO, 1);
6638 }
6640 $2->enqueue_head (*$1);
6641 delete $1;
6642 $1 = 0;
6644 // The param added above is always the last one parsed,
6645 // so we check for matches between sequence<T> & T here.
6646 ACE_CString bad_id =
6647 FE_Utils::check_for_seq_of_param (
6648 $2);
6650 if (!bad_id.empty ())
6651 {
6652 delete $2;
6653 $2 = 0;
6655 idl_global->err ()->mismatch_seq_of_param (bad_id.c_str ());
6656 return 1;
6657 }
6659 $$ = $2;
6660 }
6661 ;
6663 formal_parameters
6664 : formal_parameters ',' formal_parameter
6665 {
6666 if ($1 == 0)
6667 {
6668 ACE_NEW_RETURN ($1, FE_Utils::T_PARAMLIST_INFO, 1);
6669 }
6671 $1->enqueue_tail (*$3);
6672 $$ = $1;
6674 delete $3;
6675 $3 = 0;
6676 }
6677 | %empty
6678 {
6679 $$ = 0;
6680 }
6681 ;
6683 formal_parameter
6684 : formal_parameter_type IDENTIFIER
6685 {
6687 ACE_NEW_RETURN ($$,
6688 FE_Utils::T_Param_Info,
6689 1);
6691 AST_Decl::NodeType nt = $1;
6693 $$->type_ = nt;
6694 $$->name_ = $2;
6695 ACE::strdelete ($2);
6696 $2 = 0;
6698 if (nt == AST_Decl::NT_const)
6699 {
6700 $$->const_type_ = t_param_const_type;
6701 $$->enum_const_type_decl_ =
6702 tao_enum_constant_decl;
6704 // Reset these values.
6705 t_param_const_type = AST_Expression::EV_none;
6706 tao_enum_constant_decl = 0;
6707 }
6708 }
6709 | IDL_SEQUENCE '<' IDENTIFIER '>' IDENTIFIER
6710 {
6711 ACE_NEW_RETURN ($$,
6712 FE_Utils::T_Param_Info,
6713 1);
6715 $$->type_ = AST_Decl::NT_sequence;
6716 $$->seq_param_ref_ = $3;
6717 $$->name_ += $5;
6719 ACE::strdelete ($3);
6720 $3 = 0;
6721 ACE::strdelete ($5);
6722 $5 = 0;
6723 }
6724 ;
6726 at_least_one_formal_parameter_name
6727 : formal_parameter_name formal_parameter_names
6728 {
6729 ACE_NEW_RETURN ($$, UTL_StrList ($1, $2), 1);
6730 }
6731 ;
6733 formal_parameter_names
6734 : formal_parameter_names ',' formal_parameter_name
6735 {
6736 UTL_StrList *sl = 0;
6737 ACE_NEW_RETURN (sl, UTL_StrList ($3, 0), 1);
6739 if ($1 == 0)
6740 {
6741 $$ = sl;
6742 }
6743 else
6744 {
6745 $1->nconc (sl);
6746 $$ = $1;
6747 }
6748 }
6749 | %empty
6750 {
6751 $$ = 0;
6752 }
6753 ;
6755 formal_parameter_name
6756 : IDENTIFIER
6757 {
6758 ACE_NEW_RETURN ($$,
6759 UTL_String ($1, true),
6760 1);
6761 }
6762 ;
6764 porttype_decl
6765 : IDL_PORTTYPE
6766 {
6767 idl_global->set_parse_state (IDL_GlobalData::PS_PorttypeSeen);
6768 }
6769 IDENTIFIER
6770 {
6771 char *&id_value = $3;
6772 idl_global->set_parse_state (IDL_GlobalData::PS_PorttypeIDSeen);
6773 UTL_Scope *scope = idl_global->scopes ().top_non_null ();
6775 Identifier id (id_value);
6776 ACE::strdelete (id_value);
6777 id_value = 0;
6779 UTL_ScopedName scoped_name (&id, 0);
6780 AST_PortType *porttype = idl_global->gen ()->create_porttype (
6781 &scoped_name);
6782 scope->fe_add_porttype (porttype);
6783 $<dcval>$ = porttype;
6785 // Push it on the scopes stack.
6786 idl_global->scopes ().push (porttype);
6787 }
6788 '{'
6789 {
6790 idl_global->set_parse_state (IDL_GlobalData::PS_PorttypeSqSeen);
6791 }
6792 /**
6793 * NOTE: IDL4.2 spec has a different definition of what can go inside a
6794 * portype.
6795 */
6796 at_least_one_port_export
6797 {
6798 idl_global->set_parse_state (IDL_GlobalData::PS_PorttypeBodySeen);
6799 }
6800 '}'
6801 {
6802 idl_global->set_parse_state (IDL_GlobalData::PS_PorttypeQsSeen);
6804 // Done with this port type - pop it off the scopes stack.
6805 idl_global->scopes ().pop ();
6807 $$ = $<dcval>4;
6808 }
6809 ;
6811 at_least_one_port_export
6812 : port_exports at_least_one_annotation port_export
6813 {
6814 AST_Annotation_Appls *&annotations = $2;
6815 AST_Decl *&node = $3;
6816 if (node)
6817 {
6818 node->annotation_appls (*annotations);
6819 }
6820 else
6821 {
6822 idl_global->err ()-> unsupported_warning (
6823 "Annotating this is not supported");
6824 }
6825 delete annotations;
6826 }
6827 | port_exports port_export
6828 ;
6830 port_exports
6831 : at_least_one_port_export
6832 | %empty
6833 ;
6835 port_export
6836 : provides_decl ';'
6837 | uses_decl ';'
6838 | attribute
6839 {
6840 idl_global->set_parse_state (IDL_GlobalData::PS_AttrDeclSeen);
6841 }
6842 ';'
6843 {
6844 $$ = $1;
6845 }
6846 ;
6848 extended_port_decl
6849 : IDL_PORT scoped_name IDENTIFIER
6850 {
6851 idl_global->set_parse_state (IDL_GlobalData::PS_ExtendedPortDeclSeen);
6852 UTL_Scope *s = idl_global->scopes ().top_non_null ();
6853 AST_Decl *d =
6854 s->lookup_by_name ($2);
6855 AST_PortType *pt = 0;
6856 bool so_far_so_good = true;
6858 if (d == 0)
6859 {
6860 idl_global->err ()->lookup_error ($2);
6861 so_far_so_good = false;
6862 }
6863 else
6864 {
6865 pt = dynamic_cast<AST_PortType*> (d);
6867 if (pt == 0)
6868 {
6869 idl_global->err ()->error1 (UTL_Error::EIDL_PORTTYPE_EXPECTED,
6870 d);
6871 so_far_so_good = false;
6872 }
6873 }
6875 AST_Extended_Port *ep = 0;
6877 if (so_far_so_good)
6878 {
6879 Identifier id ($3);
6880 ACE::strdelete ($3);
6881 $3 = 0;
6883 UTL_ScopedName sn (&id, 0);
6884 ep = idl_global->gen ()->create_extended_port (&sn, pt);
6885 s->fe_add_extended_port (ep);
6887 // Create (in the AST) the struct(s) and sequence(s)
6888 // needed for multiplex uses ports, if any.
6889 for (UTL_ScopeActiveIterator i (pt, UTL_Scope::IK_decls);
6890 !i.is_done ();
6891 i.next ())
6892 {
6893 d = i.item ();
6895 AST_Uses *u = dynamic_cast<AST_Uses*> (d);
6897 if (u != 0 && u->is_multiple ())
6898 {
6899 AST_Component *c =
6900 dynamic_cast<AST_Component*> (s);
6902 FE_Utils::create_uses_multiple_stuff (
6903 c,
6904 u,
6905 id.get_string ());
6906 }
6907 }
6908 }
6910 $2->destroy ();
6911 delete $2;
6912 $2 = 0;
6914 $$ = ep;
6915 }
6916 | IDL_MIRRORPORT scoped_name IDENTIFIER
6917 {
6918 idl_global->set_parse_state (IDL_GlobalData::PS_MirrorPortDeclSeen);
6919 UTL_Scope *s = idl_global->scopes ().top_non_null ();
6920 AST_Decl *d =
6921 s->lookup_by_name ($2);
6922 AST_PortType *pt = 0;
6923 bool so_far_so_good = true;
6925 if (d == 0)
6926 {
6927 idl_global->err ()->lookup_error ($2);
6928 so_far_so_good = false;
6929 }
6930 else
6931 {
6932 pt = dynamic_cast<AST_PortType*> (d);
6934 if (pt == 0)
6935 {
6936 idl_global->err ()->error1 (UTL_Error::EIDL_PORTTYPE_EXPECTED,
6937 d);
6938 so_far_so_good = false;
6939 }
6940 }
6942 AST_Mirror_Port *mp = 0;
6944 if (so_far_so_good)
6945 {
6946 Identifier id ($3);
6947 ACE::strdelete ($3);
6948 $3 = 0;
6950 UTL_ScopedName sn (&id, 0);
6951 mp = idl_global->gen ()->create_mirror_port (&sn, pt);
6952 s->fe_add_mirror_port (mp);
6953 }
6955 $2->destroy ();
6956 delete $2;
6957 $2 = 0;
6959 $$ = mp;
6960 }
6961 ;
6963 at_least_one_actual_parameter
6964 : annotations_maybe actual_parameter actual_parameters
6965 {
6966 if ($3 == 0)
6967 {
6968 ACE_NEW_RETURN ($3,
6969 FE_Utils::T_ARGLIST,
6970 1);
6971 }
6973 delete $1;
6974 $3->enqueue_head ($2);
6975 $<alval>$ = $3;
6976 }
6977 ;
6979 actual_parameters
6980 : actual_parameters ',' annotations_maybe actual_parameter
6981 {
6982 if ($1 == 0)
6983 {
6984 ACE_NEW_RETURN ($1,
6985 FE_Utils::T_ARGLIST,
6986 1);
6987 }
6989 delete $3;
6990 $1->enqueue_tail ($4);
6991 $<alval>$ = $1;
6992 }
6993 | %empty
6994 {
6995 $<alval>$ = 0;
6996 }
6997 ;
6999 actual_parameter
7000 : expression
7001 {
7002 // To avoid grammar conflicts with this LALR(1) parser,
7003 // we take advantage of the fact that an expression can
7004 // be a scoped name. At that lower level, we create an
7005 // expression containing the scoped name, and at a
7006 // higher lever, deduce that it's not supposed to be
7007 // a constant and look up the type to add to the template
7008 // arg list.
7009 AST_Expression *ex = $1;
7010 UTL_ScopedName *sn = ex->n ();
7011 AST_Decl *d = 0;
7012 UTL_Scope *s = idl_global->scopes ().top_non_null ();
7014 if (sn != 0)
7015 {
7016 d = s->lookup_by_name (sn);
7018 if (d == 0)
7019 {
7020 idl_global->err ()->lookup_error (sn);
7021 return 1;
7022 }
7023 else
7024 {
7025 AST_Decl::NodeType nt = d->node_type ();
7027 if (nt == AST_Decl::NT_enum_val)
7028 {
7029 $1->evaluate (
7030 AST_Expression::EK_const);
7032 $<dcval>$ =
7033 idl_global->gen ()->create_constant (
7034 $1->ev ()->et,
7035 $1,
7036 sn);
7037 }
7038 else
7039 {
7040 $<dcval>$ = d;
7041 }
7042 }
7043 }
7044 else
7045 {
7046 $1->evaluate (
7047 AST_Expression::EK_const);
7049 $<dcval>$ =
7050 idl_global->gen ()->create_constant (
7051 $1->ev ()->et,
7052 $1,
7053 0);
7054 }
7055 }
7056 ;
7058 connector_decl
7059 : connector_header connector_body
7060 {
7061 $$ = 0;
7062 }
7063 ;
7065 connector_header
7066 : IDL_CONNECTOR
7067 {
7068 idl_global->set_parse_state (IDL_GlobalData::PS_ConnectorSeen);
7069 }
7070 annotations_maybe IDENTIFIER
7071 {
7072 idl_global->set_parse_state (IDL_GlobalData::PS_ConnectorIDSeen);
7073 }
7074 component_inheritance_spec
7075 {
7076 UTL_Scope *s = idl_global->scopes ().top_non_null ();
7077 AST_Connector *parent = 0;
7078 bool so_far_so_good = true;
7080 Identifier id ($4);
7081 ACE::strdelete ($4);
7082 $4 = 0;
7084 UTL_ScopedName sn (&id, 0);
7086 if ($6 != 0)
7087 {
7088 AST_Decl *d =
7089 s->lookup_by_name ($6);
7091 if (d == 0)
7092 {
7093 idl_global->err ()->lookup_error ($6);
7094 so_far_so_good = false;
7095 }
7097 parent =
7098 dynamic_cast<AST_Connector*> (d);
7100 if (parent == 0)
7101 {
7102 idl_global->err ()->error1 (
7103 UTL_Error::EIDL_CONNECTOR_EXPECTED,
7104 d);
7106 so_far_so_good = false;
7107 }
7109 $6->destroy ();
7110 delete $6;
7111 $6 = 0;
7112 }
7114 if (so_far_so_good)
7115 {
7116 AST_Connector *c =
7117 idl_global->gen ()->create_connector (&sn,
7118 parent);
7120 (void) s->fe_add_connector (c);
7122 // Push it on the scopes stack.
7123 idl_global->scopes ().push (c);
7124 }
7126 delete $3;
7127 }
7128 ;
7130 connector_body
7131 : '{'
7132 {
7133 idl_global->set_parse_state (IDL_GlobalData::PS_ConnectorSqSeen);
7134 }
7135 connector_exports
7136 {
7137 idl_global->set_parse_state (IDL_GlobalData::PS_ConnectorBodySeen);
7138 }
7139 '}'
7140 {
7141 idl_global->set_parse_state (IDL_GlobalData::PS_ConnectorQsSeen);
7143 // Done with this connector - pop it off the scope stack.
7144 idl_global->scopes ().pop ();
7145 }
7146 ;
7148 connector_exports
7149 : connector_exports connector_export
7150 | %empty
7151 ;
7153 connector_export
7154 : provides_decl
7155 {
7156 idl_global->set_parse_state (IDL_GlobalData::PS_ProvidesDeclSeen);
7157 }
7158 ';'
7159 {
7160 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
7161 }
7162 | uses_decl
7163 {
7164 idl_global->set_parse_state (IDL_GlobalData::PS_UsesDeclSeen);
7165 }
7166 ';'
7167 {
7168 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
7169 }
7170 | attribute
7171 {
7172 idl_global->set_parse_state (IDL_GlobalData::PS_AttrDeclSeen);
7173 }
7174 ';'
7175 {
7176 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
7177 }
7178 | extended_port_decl
7179 {
7180 idl_global->set_parse_state (IDL_GlobalData::PS_ExtendedPortDeclSeen);
7181 }
7182 ';'
7183 {
7184 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
7185 }
7186 ;
7188 %%
7189 /* programs */
7191 /*
7192 * ???
7193 */
7194 int
7195 tao_yywrap (void)
7196 {
7197 return 1;
7198 }
7200 /*
7201 * Report an error situation discovered in a production
7202 */
7203 void
7204 tao_yyerror (const char *msg)
7205 {
7206 ACE_ERROR ((LM_ERROR, "%C\n", msg));
7207 }