| blob | ff2d5b66773107a24220b7b87a371a6d210f2c08 |
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>
134 #include <ast_map.h>
136 #include <fe_declarator.h>
137 #include <fe_interface_header.h>
138 #include <fe_obv_header.h>
139 #include <fe_component_header.h>
140 #include <fe_home_header.h>
141 #include <fe_utils.h>
143 void tao_yyerror (const char *);
144 int tao_yylex (void);
145 extern "C" int tao_yywrap (void);
147 extern char tao_yytext[];
148 extern int tao_yyleng;
150 AST_Enum *tao_enum_constant_decl = 0;
151 AST_String *tao_string_decl = 0;
152 AST_Expression::ExprType t_param_const_type = AST_Expression::EV_none;
153 bool stack_based_lookup_for_primary_expr = false;
155 #define TAO_YYDEBUG_LEXER_TEXT (tao_yytext[tao_yyleng] = '\0', tao_yytext)
156 // Compile Optional Tracing Output for Parser, can be enabled with --bison-trace
157 #define YYDEBUG 1
158 %}
160 /*
161 * Declare the type of values in the grammar
162 */
164 %union {
165 AST_Decl *dcval; /* Decl value */
166 UTL_StrList *slval; /* String list */
167 UTL_NameList *nlval; /* Name list */
168 UTL_ExprList *elval; /* Expression list */
169 UTL_LabelList *llval; /* Label list */
170 UTL_DeclList *dlval; /* Declaration list */
171 FE_InterfaceHeader *ihval; /* Interface header */
172 FE_OBVHeader *vhval; /* Valuetype header */
173 FE_ComponentHeader *chval; /* Component header */
174 FE_HomeHeader *hhval; /* Home header */
175 AST_Expression *exval; /* Expression value */
176 AST_UnionLabel *ulval; /* Union label */
177 AST_Field *ffval; /* Field value */
178 AST_Field::Visibility vival; /* N/A, pub or priv */
179 AST_Expression::ExprType etval; /* Expression type */
180 AST_Argument::Direction dival; /* Argument direction */
181 AST_Operation::Flags ofval; /* Operation flags */
182 FE_Declarator *deval; /* Declarator value */
183 ACE_CDR::Boolean bval; /* Boolean value */
184 ACE_CDR::LongLong ival; /* Long Long value */
185 ACE_CDR::ULongLong uival; /* Unsigned long long */
186 ACE_CDR::Double dval; /* Double value */
187 ACE_CDR::Float fval; /* Float value */
188 ACE_CDR::Char cval; /* Char value */
189 ACE_CDR::WChar wcval; /* WChar value */
190 ACE_CDR::Fixed fixval; /* Fixed point value */
191 UTL_String *sval; /* String value */
192 char *wsval; /* WString value */
193 char *strval; /* char * value */
194 Identifier *idval; /* Identifier */
195 UTL_IdList *idlist; /* Identifier list */
196 AST_Decl::NodeType ntval; /* Node type value */
197 FE_Utils::T_Param_Info *pival; /* Template interface param */
198 FE_Utils::T_PARAMLIST_INFO *plval; /* List of template params */
199 FE_Utils::T_ARGLIST *alval; /* List of template args */
200 AST_Annotation_Appl *annotation_val;
201 AST_Annotation_Appls *annotations_val;
202 AST_Annotation_Appl::Param *annotation_param_val;
203 AST_Annotation_Appl::Params *annotation_params_val;
204 AST_Annotation_Decl *annotation_decl_val;
205 AST_Decls *decls_val;
206 Decl_Annotations_Pair *decl_annotations_pair_val;
207 Decl_Annotations_Pair_Pair* decl_annotations_pair_val_pair;
208 }
210 /*
211 * Token types: These are returned by the lexer
212 */
214 %token <strval> IDENTIFIER
216 %token IDL_CONST
217 %token IDL_MODULE
218 %token IDL_INTERFACE
219 %token IDL_TYPEDEF
220 %token IDL_LONG
221 %token IDL_SHORT
222 %token IDL_UNSIGNED
223 %token IDL_DOUBLE
224 %token IDL_FLOAT
225 %token IDL_CHAR
226 %token IDL_WCHAR
227 %token IDL_OCTET
228 %token IDL_BOOLEAN
229 %token IDL_FIXED
230 %token IDL_ANY
231 %token IDL_OBJECT
232 %token IDL_STRUCT
233 %token IDL_UNION
234 %token IDL_SWITCH
235 %token IDL_ENUM
236 %token IDL_SEQUENCE
237 %token IDL_MAP
238 %token IDL_STRING
239 %token IDL_WSTRING
240 %token IDL_EXCEPTION
241 %token IDL_CASE
242 %token IDL_DEFAULT
243 %token IDL_READONLY
244 %token IDL_ATTRIBUTE
245 %token IDL_ONEWAY
246 %token IDL_IDEMPOTENT
247 %token IDL_VOID
248 %token IDL_IN
249 %token IDL_OUT
250 %token IDL_INOUT
251 %token IDL_RAISES
252 %token IDL_CONTEXT
253 %token IDL_NATIVE
254 %token IDL_LOCAL
255 /* OBV tokens */
256 %token IDL_ABSTRACT
257 %token IDL_CUSTOM
258 %token IDL_FACTORY
259 %token IDL_PRIVATE
260 %token IDL_PUBLIC
261 %token IDL_SUPPORTS
262 %token IDL_TRUNCATABLE
263 %token IDL_VALUETYPE
264 /* Component tokens */
265 %token IDL_COMPONENT
266 %token IDL_CONSUMES
267 %token IDL_EMITS
268 %token IDL_EVENTTYPE
269 %token IDL_FINDER
270 %token IDL_GETRAISES
271 %token IDL_HOME
272 %token IDL_IMPORT
273 %token IDL_MULTIPLE
274 %token IDL_PRIMARYKEY
275 %token IDL_PROVIDES
276 %token IDL_PUBLISHES
277 %token IDL_SETRAISES
278 %token IDL_TYPEID
279 %token IDL_TYPEPREFIX
280 %token IDL_USES
281 %token IDL_MANAGES
282 /* Extended ports tokens */
283 %token IDL_TYPENAME
284 %token IDL_PORT
285 %token IDL_MIRRORPORT
286 %token IDL_PORTTYPE
287 %token IDL_CONNECTOR
288 %token IDL_ALIAS
290 %token <ival> IDL_INTEGER_LITERAL
291 %token <uival> IDL_UINTEGER_LITERAL
292 %token <sval> IDL_STRING_LITERAL
293 %token <cval> IDL_CHARACTER_LITERAL
294 %token <dval> IDL_FLOATING_PT_LITERAL
295 %token <fixval> IDL_FIXED_PT_LITERAL
296 %token IDL_TRUETOK
297 %token IDL_FALSETOK
299 /* stdint like types defined in IDL4.2 7.4.13 */
300 %token IDL_INT8
301 %token IDL_UINT8
302 %token IDL_INT16
303 %token IDL_UINT16
304 %token IDL_INT32
305 %token IDL_UINT32
306 %token IDL_INT64
307 %token IDL_UINT64
309 %token <strval> IDL_SCOPE_DELIMITOR
310 %token IDL_LEFT_SHIFT
311 %token IDL_RIGHT_SHIFT
312 %token <wcval> IDL_WCHAR_LITERAL
313 %token <wsval> IDL_WSTRING_LITERAL
315 %token IDL_ANNOTATION_DECL
316 %token IDL_ANNOTATION_SYMBOL
318 /*
319 * These are production names:
320 */
322 %type <dcval> type_spec simple_type_spec constructed_type_spec
323 %type <dcval> template_type_spec sequence_type_spec string_type_spec map_type_spec
324 %type <dcval> struct_type enum_type switch_type_spec union_type
325 %type <dcval> array_declarator op_type_spec wstring_type_spec
326 %type <dcval> param_type_spec type_dcl type_declarator actual_parameter
327 %type <dcval> fixed_type_spec
328 %type <dcval> definition fixed_definition module const_dcl struct_forward_type
329 %type <dcval> interface_def interface interface_forward
330 %type <dcval> export operation attribute attribute_readonly attribute_readwrite
331 %type <dcval> template_module template_module_inst annotation_dcl typeid_dcl
332 %type <dcval> typeprefix_dcl exception component home_decl
333 %type <dcval> event_decl event_abs_decl event_forward_decl
334 %type <dcval> event_abs_forward_decl event_concrete_forward_decl
335 %type <dcval> porttype_decl connector_decl value_def
336 %type <dcval> valuetype value_abs_decl value_forward_decl value_box_decl
337 %type <dcval> value_concrete_decl component_forward_decl component_decl
338 %type <dcval> init_decl provides_decl uses_decl port_export
339 %type <dcval> component_export emits_decl publishes_decl consumes_decl
340 %type <dcval> extended_port_decl
342 %type <idlist> scoped_name interface_type component_inheritance_spec
343 %type <idlist> home_inheritance_spec primary_key_spec module_header
344 %type <idlist> template_module_header
346 %type <slval> opt_context at_least_one_string_literal
347 %type <slval> string_literals formal_parameter_names
348 %type <slval> at_least_one_formal_parameter_name
350 %type <nlval> at_least_one_scoped_name scoped_names inheritance_spec
351 %type <nlval> opt_raises opt_getraises opt_setraises supports_spec
353 %type <elval> at_least_one_array_dim array_dims
355 %type <llval> at_least_one_case_label case_labels
357 %type <dlval> at_least_one_declarator declarators
358 %type <dlval> at_least_one_simple_declarator simple_declarators
360 %type <ihval> interface_header
362 %type <vhval> value_header event_rest_of_header
364 %type <chval> component_header
366 %type <hhval> home_header
368 %type <exval> expression const_expr or_expr xor_expr and_expr shift_expr
369 %type <exval> add_expr mult_expr unary_expr primary_expr literal
370 %type <exval> positive_int_expr array_dim annotation_member_default
372 %type <ulval> case_label
374 %type <ffval> element_spec
376 %type <etval> const_type integer_type char_type boolean_type
377 %type <etval> floating_pt_type fixed_type any_type signed_int
378 %type <etval> unsigned_int base_type_spec octet_type object_type
379 %type <etval> annotation_member_type
381 %type <dival> direction
383 %type <ofval> opt_op_attribute
385 %type <deval> declarator simple_declarator complex_declarator
387 %type <bval> opt_truncatable opt_multiple uses_opt_multiple
389 %type <idval> interface_decl value_decl union_decl struct_decl id
390 %type <idval> defining_id
391 %type <idval> event_header event_plain_header event_custom_header
392 %type <idval> event_abs_header
394 %type <ntval> formal_parameter_type
396 %type <pival> formal_parameter
397 %type <plval> formal_parameters at_least_one_formal_parameter
399 %type <sval> formal_parameter_name
401 %type <alval> actual_parameters at_least_one_actual_parameter
403 %type <annotations_val> at_least_one_annotation annotations_maybe
404 %type <annotation_val> annotation_appl
405 %type <annotation_params_val> annotation_appl_params_maybe annotation_appl_params
406 %type <annotation_params_val> named_annotation_appl_params more_named_annotation_appl_params
407 %type <annotation_param_val> named_annotation_appl_param
408 %type <decl_annotations_pair_val> seq_head
410 %type <decl_annotations_pair_val_pair> map_head
412 %type <decls_val> member_i state_member value_element
413 %type <vival> visibility
414 %%
416 /*
417 * Production starts here.
418 */
419 start : definitions ;
421 definitions
422 : at_least_one_definition
423 | %empty
424 ;
426 at_least_one_definition
427 /*
428 * This is broken up into 2 rules to avoid a grammer ambiguity which
429 * manifests as bison complaining about shift/reduce conflicts.
430 */
431 : definitions at_least_one_annotation definition
432 {
433 AST_Annotation_Appls *&annotations = $2;
434 AST_Decl *&node = $3;
435 if (node)
436 {
437 node->annotation_appls (*annotations);
438 }
439 else
440 {
441 idl_global->err ()-> unsupported_warning (
442 "Annotating this is not supported");
443 }
444 delete annotations;
445 }
446 | definitions definition
447 ;
449 definition
450 : fixed_definition
451 | template_module ';'
452 | template_module_inst ';'
453 ;
455 fixed_definition
456 : annotation_dcl
457 {
458 idl_global->set_parse_state (IDL_GlobalData::PS_AnnotationDeclSeen);
459 }
460 ';'
461 {
462 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
463 }
464 | type_dcl
465 {
466 idl_global->set_parse_state (IDL_GlobalData::PS_TypeDeclSeen);
467 }
468 ';'
469 {
470 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
471 }
472 | typeid_dcl
473 {
474 idl_global->set_parse_state (IDL_GlobalData::PS_TypeIdDeclSeen);
475 }
476 ';'
477 {
478 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
479 }
480 | typeprefix_dcl
481 {
482 idl_global->set_parse_state (IDL_GlobalData::PS_TypePrefixDeclSeen);
483 }
484 ';'
485 {
486 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
487 }
488 | const_dcl
489 {
490 idl_global->set_parse_state (IDL_GlobalData::PS_ConstDeclSeen);
491 }
492 ';'
493 {
494 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
495 }
496 | exception
497 {
498 idl_global->set_parse_state (IDL_GlobalData::PS_ExceptDeclSeen);
499 }
500 ';'
501 {
502 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
503 }
504 | interface_def
505 {
506 idl_global->set_parse_state (IDL_GlobalData::PS_InterfaceDeclSeen);
507 }
508 ';'
509 {
510 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
511 }
512 | module
513 {
514 idl_global->set_parse_state (IDL_GlobalData::PS_ModuleDeclSeen);
515 }
516 ';'
517 {
518 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
519 }
520 | value_def
521 {
522 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeDeclSeen);
523 }
524 ';'
525 {
526 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
527 }
528 | component
529 {
530 idl_global->set_parse_state (IDL_GlobalData::PS_ComponentDeclSeen);
531 }
532 ';'
533 {
534 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
535 }
536 | home_decl
537 {
538 idl_global->set_parse_state (IDL_GlobalData::PS_HomeDeclSeen);
539 }
540 ';'
541 {
542 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
543 }
544 | event
545 {
546 idl_global->set_parse_state (IDL_GlobalData::PS_EventDeclSeen);
547 }
548 ';'
549 {
550 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
551 }
552 | porttype_decl
553 {
554 idl_global->set_parse_state (IDL_GlobalData::PS_PorttypeDeclSeen);
555 }
556 ';'
557 {
558 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
559 }
560 | connector_decl
561 {
562 idl_global->set_parse_state (IDL_GlobalData::PS_ConnectorDeclSeen);
563 }
564 ';'
565 {
566 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
567 }
568 | error
569 {
570 idl_global->err ()->syntax_error (idl_global->parse_state ());
571 }
572 ';'
573 {
574 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
575 yyerrok;
576 $$ = 0;
577 }
578 ;
580 module_header
581 : IDL_MODULE
582 {
583 idl_global->set_parse_state (IDL_GlobalData::PS_ModuleSeen);
584 }
585 scoped_name
586 {
587 $<idlist>$ = $3;
588 }
589 ;
591 module
592 : module_header
593 {
594 idl_global->set_parse_state (IDL_GlobalData::PS_ModuleIDSeen);
596 // The module_header rule is common to template module, fixed
597 // module and instantiated template module. In the last
598 // case, a fully scoped name is allowed, but here we
599 // allow only an identifier (a scoped name of length
600 // 1). If not satisfied, we output a parse error with
601 // the appropriate message.
602 if ($1->length () != 1)
603 {
604 idl_global->err ()->syntax_error (
605 IDL_GlobalData::PS_ModuleIDSeen);
606 }
608 AST_Module *m = 0;
609 UTL_Scope *s = idl_global->scopes ().top_non_null ();
611 /*
612 * Make a new module and add it to the enclosing scope
613 */
614 if (s != 0)
615 {
616 m = idl_global->gen ()->create_module (s, $1);
617 (void) s->fe_add_module (m);
618 }
620 $1->destroy ();
621 delete $1;
622 $1 = 0;
624 /*
625 * Push it on the stack
626 */
627 idl_global->scopes ().push (m);
629 $<dcval>$ = m;
630 }
631 '{'
632 {
633 idl_global->set_parse_state (IDL_GlobalData::PS_ModuleSqSeen);
634 }
635 at_least_one_definition
636 {
637 idl_global->set_parse_state (IDL_GlobalData::PS_ModuleBodySeen);
638 }
639 '}'
640 {
641 idl_global->set_parse_state (IDL_GlobalData::PS_ModuleQsSeen);
642 /*
643 * Finished with this module - pop it from the scope stack.
644 */
646 idl_global->scopes ().pop ();
647 $$ = $<dcval>2;
648 }
649 ;
651 template_module_header
652 : module_header '<'
653 {
654 idl_global->set_parse_state (IDL_GlobalData::PS_TmplModuleIDSeen);
655 }
656 ;
658 template_module
659 : template_module_header
660 {
661 // The module_header rule is common to template module, fixed
662 // module and instantiated template module. In the last
663 // case, a fully scoped name is allowed, but here we
664 // allow only an identifier (a scoped name of length
665 // 1). If not satisfied, we output a syntax error with
666 // the appropriate message.
667 if ($1->length () != 1)
668 {
669 idl_global->err ()->syntax_error (
670 IDL_GlobalData::PS_ModuleIDSeen);
671 }
672 }
673 at_least_one_formal_parameter
674 {
675 if (FE_Utils::duplicate_param_id ($3))
676 {
677 idl_global->err ()->duplicate_param_id (
678 $1);
680 return 1;
681 }
682 }
683 '>'
684 {
685 idl_global->set_parse_state (IDL_GlobalData::PS_TmplModuleParamsSeen);
687 AST_Template_Module *tm =
688 idl_global->gen ()->create_template_module ($1,
689 $3);
691 UTL_Scope *s = idl_global->scopes ().top_non_null ();
692 AST_Module *m = s->fe_add_module (tm);
694 // We've probably tried to reopen a template module,
695 // going further will cause a crash.
696 if (m == 0)
697 {
698 return 1;
699 }
701 /*
702 * Push it on the stack
703 */
704 idl_global->scopes ().push (tm);
706 // Contained items not part of an alias will get flag set.
707 idl_global->in_tmpl_mod_no_alias (true);
709 // Store these for reference as we parse the scope
710 // of the template module.
711 idl_global->current_params ($3);
712 }
713 '{'
714 {
715 idl_global->set_parse_state (IDL_GlobalData::PS_TmplModuleSqSeen);
716 }
717 at_least_one_tpl_definition
718 {
719 idl_global->set_parse_state (IDL_GlobalData::PS_TmplModuleBodySeen);
720 }
721 '}'
722 {
723 idl_global->set_parse_state (IDL_GlobalData::PS_TmplModuleQsSeen);
725 /*
726 * Finished with this module - pop it from the scope stack.
727 */
728 idl_global->scopes ().pop ();
730 // Unset the flag, the no_alias version because any scope
731 // traversal triggered by an alias would have ended by now.
732 idl_global->in_tmpl_mod_no_alias (false);
734 // Clear the pointer so scoped name lookup will know
735 // that we are no longer in a template module scope.
736 idl_global->current_params (0);
738 $$ = 0;
739 }
740 ;
742 at_least_one_tpl_definition
743 : tpl_definition tpl_definitions
744 ;
746 tpl_definitions
747 : tpl_definitions tpl_definition
748 | %empty
749 ;
751 tpl_definition
752 : fixed_definition
753 | template_module_ref ';'
754 ;
756 template_module_ref
757 : IDL_ALIAS scoped_name
758 {
759 idl_global->set_parse_state (
760 IDL_GlobalData::PS_ModuleRefSeen);
761 }
762 '<' at_least_one_formal_parameter_name '>'
763 {
764 idl_global->set_parse_state (
765 IDL_GlobalData::PS_ModuleRefParamsSeen);
766 }
767 defining_id
768 {
769 idl_global->set_parse_state (
770 IDL_GlobalData::PS_ModuleRefIDSeen);
772 UTL_Scope *s = idl_global->scopes ().top_non_null ();
773 AST_Decl *d =
774 s->lookup_by_name ($2);
776 if (d == 0)
777 {
778 idl_global->err ()->lookup_error ($2);
779 return 1;
780 }
782 AST_Template_Module *ref =
783 dynamic_cast<AST_Template_Module*> (d);
785 if (ref == 0)
786 {
787 idl_global->err ()->template_module_expected (d);
788 return 1;
789 }
791 bool refs_match =
792 ref->match_param_refs ($5,
793 s);
795 if (! refs_match)
796 {
797 // Error message is already output.
798 return 1;
799 }
801 UTL_ScopedName sn ($8, 0);
803 AST_Template_Module_Ref *tmr =
804 idl_global->gen ()->create_template_module_ref (
805 &sn,
806 ref,
807 $5);
809 (void) s->fe_add_template_module_ref (tmr);
811 sn.destroy ();
812 $2->destroy ();
813 delete $2;
814 $2 = 0;
816 // Save the current flag value to be restored below.
817 bool itmna_flag = idl_global->in_tmpl_mod_no_alias ();
818 idl_global->in_tmpl_mod_no_alias (false);
819 idl_global->in_tmpl_mod_alias (true);
821 ast_visitor_context ctx;
822 ctx.template_params (ref->template_params ());
823 ast_visitor_tmpl_module_ref v (&ctx);
825 // The implied IDL resulting from this reference is
826 // created here, in the template module scope. Upon
827 // instantiation of the enclosing template module, the
828 // visitor copies this implied IDL to the instantiated
829 // module scope. The extra copy is less than ideal, but
830 // otherwise we have ugly lookup issues when the
831 // referenced template module's contents are referenced
832 // using the aliased scoped name.
833 if (v.visit_template_module_ref (tmr) != 0)
834 {
835 ACE_ERROR ((LM_ERROR,
836 ACE_TEXT ("visit_template_module_ref")
837 ACE_TEXT (" failed\n")));
839 idl_global->set_err_count (idl_global->err_count () + 1);
840 }
842 idl_global->in_tmpl_mod_no_alias (itmna_flag);
843 idl_global->in_tmpl_mod_alias (false);
844 }
845 ;
847 template_module_inst
848 : template_module_header
849 {
850 idl_global->set_parse_state (
851 IDL_GlobalData::PS_InstModuleSeen);
852 }
853 at_least_one_actual_parameter '>'
854 {
855 idl_global->set_parse_state (
856 IDL_GlobalData::PS_InstModuleArgsSeen);
857 }
858 defining_id
859 {
860 idl_global->set_parse_state (
861 IDL_GlobalData::PS_InstModuleIDSeen);
863 UTL_Scope *s = idl_global->scopes ().top_non_null ();
864 UTL_ScopedName *sn = $1;
865 AST_Template_Module *ref = 0;
866 AST_Decl *d = s->lookup_by_name (sn);
868 if (d == 0)
869 {
870 idl_global->err ()->lookup_error (sn);
871 return 1;
872 }
873 else
874 {
875 ref = dynamic_cast<AST_Template_Module*> (d);
877 if (ref == 0)
878 {
879 idl_global->err ()->template_module_expected (d);
880 return 1;
881 }
882 }
884 sn->destroy ();
885 delete sn;
886 sn = 0;
887 $1 = 0;
889 if (! ref->match_arg_names ($3))
890 {
891 return 1;
892 }
894 ACE_NEW_RETURN (sn,
895 UTL_ScopedName ($6,
896 0),
897 1);
899 AST_Template_Module_Inst *tmi =
900 idl_global->gen ()->create_template_module_inst (
901 sn,
902 ref,
903 $3);
905 (void) s->fe_add_template_module_inst (tmi);
907 ast_visitor_context ctx;
908 ctx.template_args ($3);
909 ast_visitor_tmpl_module_inst v (&ctx);
911 if (v.visit_template_module_inst (tmi) != 0)
912 {
913 ACE_ERROR ((LM_ERROR,
914 ACE_TEXT ("visit_template_module_inst")
915 ACE_TEXT (" failed\n")));
917 idl_global->set_err_count (idl_global->err_count () + 1);
918 }
920 $$ = 0;
921 }
922 ;
924 interface_def
925 : interface
926 | interface_forward
927 ;
929 interface
930 : interface_header
931 {
932 UTL_Scope *s = idl_global->scopes ().top_non_null ();
933 AST_Interface *i = 0;
935 FE_InterfaceHeader *header = $1;
936 $1 = 0;
938 /*
939 * Make a new interface node and add it to its enclosing scope.
940 */
941 if (s && header)
942 {
943 i = idl_global->gen ()->create_interface (
944 header->name (),
945 header->inherits (),
946 header->n_inherits (),
947 header->inherits_flat (),
948 header->n_inherits_flat (),
949 header->is_local (),
950 header->is_abstract ()
951 );
952 AST_Interface::fwd_redefinition_helper (i, s);
953 /*
954 * Add the interface to its definition scope.
955 */
956 s->fe_add_interface (i);
958 // This FE_InterfaceHeader class isn't destroyed with the AST.
959 header->destroy ();
960 delete header;
961 }
963 /*
964 * Push it on the scope stack.
965 */
966 idl_global->scopes ().push (i);
967 }
968 '{'
969 {
970 idl_global->set_parse_state (IDL_GlobalData::PS_InterfaceSqSeen);
971 }
972 exports
973 {
974 idl_global->set_parse_state (IDL_GlobalData::PS_InterfaceBodySeen);
975 }
976 '}'
977 {
978 idl_global->set_parse_state (IDL_GlobalData::PS_InterfaceQsSeen);
980 $$ = dynamic_cast<AST_Decl *> (idl_global->scopes ().top_non_null ());
981 /*
982 * Done with this interface - pop it off the scopes stack
983 */
984 idl_global->scopes ().pop ();
985 }
986 ;
988 interface_decl:
989 IDL_INTERFACE
990 {
991 idl_global->set_parse_state (IDL_GlobalData::PS_InterfaceSeen);
992 }
993 defining_id
994 {
995 idl_global->set_parse_state (IDL_GlobalData::PS_InterfaceIDSeen);
996 $$ = $3;
997 }
998 ;
1000 interface_header :
1001 interface_decl inheritance_spec
1002 {
1003 idl_global->set_parse_state (IDL_GlobalData::PS_InheritSpecSeen);
1005 if ($2 != 0 && $2->truncatable ())
1006 {
1007 idl_global->err ()->syntax_error (
1008 IDL_GlobalData::PS_InheritColonSeen
1009 );
1010 }
1012 /*
1013 * Create an AST representation of the information in the header
1014 * part of an interface - this representation contains a computed
1015 * list of all interfaces which this interface inherits from,
1016 * recursively
1017 */
1018 UTL_ScopedName *n = 0;
1019 ACE_NEW_RETURN (n,
1020 UTL_ScopedName ($1, 0),
1021 1);
1022 ACE_NEW_RETURN ($$,
1023 FE_InterfaceHeader (n,
1024 $2,
1025 false,
1026 false,
1027 true),
1028 1);
1030 if (0 != $2)
1031 {
1032 $2->destroy ();
1033 delete $2;
1034 $2 = 0;
1035 }
1036 }
1037 |
1038 IDL_LOCAL interface_decl inheritance_spec
1039 {
1040 idl_global->set_parse_state (IDL_GlobalData::PS_InheritSpecSeen);
1042 /*
1043 * Create an AST representation of the information in the header
1044 * part of an interface - this representation contains a computed
1045 * list of all interfaces which this interface inherits from,
1046 * recursively
1047 */
1048 UTL_ScopedName *n = 0;
1049 ACE_NEW_RETURN (n,
1050 UTL_ScopedName ($2, 0),
1051 1);
1052 ACE_NEW_RETURN ($$,
1053 FE_InterfaceHeader (n,
1054 $3,
1055 true,
1056 false,
1057 true),
1058 1);
1060 if (0 != $3)
1061 {
1062 $3->destroy ();
1063 delete $3;
1064 $3 = 0;
1065 }
1066 }
1067 |
1068 IDL_ABSTRACT interface_decl inheritance_spec
1069 {
1070 idl_global->set_parse_state (IDL_GlobalData::PS_InheritSpecSeen);
1072 /*
1073 * Create an AST representation of the information in the header
1074 * part of an interface - this representation contains a computed
1075 * list of all interfaces which this interface inherits from,
1076 * recursively
1077 */
1078 UTL_ScopedName *n = 0;
1079 ACE_NEW_RETURN (n,
1080 UTL_ScopedName ($2, 0),
1081 1);
1082 ACE_NEW_RETURN ($$,
1083 FE_InterfaceHeader (n,
1084 $3,
1085 false,
1086 true,
1087 true),
1088 1);
1090 if (0 != $3)
1091 {
1092 $3->destroy ();
1093 delete $3;
1094 $3 = 0;
1095 }
1096 }
1097 ;
1099 inheritance_spec
1100 : ':' opt_truncatable
1101 {
1102 idl_global->set_parse_state (IDL_GlobalData::PS_InheritColonSeen);
1103 }
1104 at_least_one_scoped_name
1105 {
1106 $4->truncatable ($2);
1107 $$ = $4;
1108 }
1109 | %empty
1110 {
1111 $$ = 0;
1112 }
1113 ;
1115 value_def
1116 : valuetype
1117 | value_abs_decl
1118 | value_forward_decl
1119 | value_box_decl
1120 ;
1122 valuetype
1123 : IDL_CUSTOM value_concrete_decl
1124 {
1125 idl_global->err ()->unsupported_error ("custom is not supported");
1126 $<dcval>$ = $2;
1127 }
1128 | value_concrete_decl
1129 ;
1131 value_concrete_decl :
1132 value_header
1133 {
1134 FE_OBVHeader *&valuetype_header = $1;
1135 UTL_Scope *scope = idl_global->scopes ().top_non_null ();
1136 AST_ValueType *valuetype = 0;
1138 if (scope && valuetype_header)
1139 {
1140 valuetype = idl_global->gen ()->create_valuetype (
1141 valuetype_header->name (),
1142 valuetype_header->inherits (),
1143 valuetype_header->n_inherits (),
1144 valuetype_header->inherits_concrete (),
1145 valuetype_header->inherits_flat (),
1146 valuetype_header->n_inherits_flat (),
1147 valuetype_header->supports (),
1148 valuetype_header->n_supports (),
1149 valuetype_header->supports_concrete (),
1150 false,
1151 valuetype_header->truncatable (),
1152 false);
1154 AST_Interface *valuetype_as_interface =
1155 dynamic_cast<AST_Interface *> (valuetype);
1156 AST_Interface::fwd_redefinition_helper (
1157 valuetype_as_interface, scope);
1158 valuetype = dynamic_cast<AST_ValueType *> (
1159 valuetype_as_interface);
1161 /*
1162 * Add the valuetype to its definition scope
1163 */
1164 scope->fe_add_valuetype (valuetype);
1166 // FE_OBVHeader is not automatically destroyed in the AST
1167 valuetype_header->destroy ();
1168 delete valuetype_header;
1169 valuetype_header = 0;
1170 }
1172 /*
1173 * Push it on the scope stack
1174 */
1175 idl_global->scopes ().push (valuetype);
1177 $<dcval>$ = valuetype;
1178 }
1179 '{'
1180 {
1181 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeSqSeen);
1182 }
1183 value_elements
1184 {
1185 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeBodySeen);
1186 }
1187 '}'
1188 {
1189 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeQsSeen);
1191 AST_ValueType *vt =
1192 dynamic_cast<AST_ValueType*> (
1193 idl_global->scopes ().top_non_null ()
1194 );
1196 if (vt != 0 && vt->will_have_factory ())
1197 {
1198 idl_global->valuefactory_seen_ = true;
1199 }
1201 /*
1202 * Done with this value type - pop it off the scopes stack
1203 */
1204 idl_global->scopes ().pop ();
1206 $$ = $<dcval>2;
1207 }
1208 ;
1210 value_abs_decl :
1211 IDL_ABSTRACT
1212 value_header
1213 {
1214 UTL_Scope *s = idl_global->scopes ().top_non_null ();
1215 AST_ValueType *v = 0;
1216 AST_Interface *i = 0;
1218 if (s != 0 && $2 != 0)
1219 {
1220 v =
1221 idl_global->gen ()->create_valuetype (
1222 $2->name (),
1223 $2->inherits (),
1224 $2->n_inherits (),
1225 $2->inherits_concrete (),
1226 $2->inherits_flat (),
1227 $2->n_inherits_flat (),
1228 $2->supports (),
1229 $2->n_supports (),
1230 $2->supports_concrete (),
1231 true,
1232 false,
1233 false
1234 );
1235 i = dynamic_cast<AST_Interface*> (v);
1236 AST_Interface::fwd_redefinition_helper (i,
1237 s);
1238 /*
1239 * Add the valuetype to its definition scope
1240 */
1241 v = dynamic_cast<AST_ValueType*> (i);
1242 (void) s->fe_add_valuetype (v);
1244 // FE_OBVHeader is not automatically destroyed in the AST
1245 $2->destroy ();
1246 delete $2;
1247 $2 = 0;
1248 }
1250 /*
1251 * Push it on the scope stack.
1252 */
1253 idl_global->scopes ().push (v);
1254 }
1255 '{'
1256 {
1257 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeSqSeen);
1258 }
1259 exports
1260 {
1261 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeBodySeen);
1262 }
1263 '}'
1264 {
1265 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeQsSeen);
1267 /*
1268 * Done with this valuetype - pop it off the scopes stack.
1269 */
1270 idl_global->scopes ().pop ();
1272 $$ = 0;
1273 }
1274 ;
1276 value_header :
1277 value_decl
1278 inheritance_spec
1279 {
1280 idl_global->set_parse_state (IDL_GlobalData::PS_InheritSpecSeen);
1281 }
1282 supports_spec
1283 {
1284 idl_global->set_parse_state (IDL_GlobalData::PS_SupportSpecSeen);
1286 UTL_ScopedName *sn = 0;
1287 ACE_NEW_RETURN (sn,
1288 UTL_ScopedName ($1, 0),
1289 1);
1290 ACE_NEW_RETURN ($$,
1291 FE_OBVHeader (sn,
1292 $2,
1293 $4,
1294 ($2 != 0
1295 ? $2->truncatable ()
1296 : false)),
1297 1);
1299 if (0 != $4)
1300 {
1301 $4->destroy ();
1302 delete $4;
1303 $4 = 0;
1304 }
1306 if (0 != $2)
1307 {
1308 $2->destroy ();
1309 delete $2;
1310 $2 = 0;
1311 }
1312 }
1313 ;
1315 value_decl
1316 : IDL_VALUETYPE
1317 {
1318 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeSeen);
1319 }
1320 defining_id
1321 {
1322 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeIDSeen);
1323 $$ = $3;
1324 }
1325 ;
1327 opt_truncatable :
1328 IDL_TRUNCATABLE
1329 {
1330 $$ = true;
1331 }
1332 | %empty
1333 {
1334 $$ = false;
1335 }
1336 ;
1338 supports_spec :
1339 IDL_SUPPORTS
1340 at_least_one_scoped_name
1341 {
1342 $$ = $2;
1343 }
1344 | %empty
1345 {
1346 $$ = 0;
1347 }
1348 ;
1350 value_forward_decl :
1351 IDL_ABSTRACT
1352 value_decl
1353 {
1354 UTL_Scope *s = idl_global->scopes ().top_non_null ();
1355 UTL_ScopedName n ($2,
1356 0);
1357 AST_ValueTypeFwd *f = 0;
1358 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeForwardSeen);
1360 /*
1361 * Create a node representing a forward declaration of an
1362 * valuetype. Store it in the enclosing scope
1363 */
1364 if (s != 0)
1365 {
1366 f = idl_global->gen ()->create_valuetype_fwd (&n,
1367 true);
1368 (void) s->fe_add_valuetype_fwd (f);
1369 }
1371 $2->destroy ();
1372 delete $2;
1373 $2 = 0;
1374 }
1375 |
1376 value_decl
1377 {
1378 UTL_Scope *s = idl_global->scopes ().top_non_null ();
1379 UTL_ScopedName n ($1,
1380 0);
1381 AST_ValueTypeFwd *f = 0;
1382 idl_global->set_parse_state (IDL_GlobalData::PS_ValueTypeForwardSeen);
1384 /*
1385 * Create a node representing a forward declaration of an
1386 * valuetype. Store it in the enclosing scope
1387 */
1388 if (s != 0)
1389 {
1390 f = idl_global->gen ()->create_valuetype_fwd (&n,
1391 false);
1392 (void) s->fe_add_valuetype_fwd (f);
1393 }
1395 $1->destroy ();
1396 delete $1;
1397 $1 = 0;
1399 $$ = 0;
1400 }
1401 ;
1403 value_box_decl
1404 : value_decl type_spec /* in this order %!?*/
1405 {
1406 idl_global->set_parse_state (IDL_GlobalData::PS_ValueBoxDeclSeen);
1408 UTL_Scope *s = idl_global->scopes ().top_non_null ();
1409 UTL_ScopedName n ($1,
1410 0);
1412 if (s != 0 && $2 != 0)
1413 {
1414 /*
1415 * Get the type_spec associated with the valuebox
1416 */
1417 AST_Type *tp = 0;
1418 AST_Typedef *td
1419 = dynamic_cast<AST_Typedef*> ($2);
1421 if (td == 0)
1422 {
1423 tp = dynamic_cast<AST_Type*> ($2);
1424 }
1425 else
1426 {
1427 tp = td->primitive_base_type ();
1428 }
1430 if (tp == 0)
1431 {
1432 // The <type_spec> given is a valid type
1433 idl_global->err ()->not_a_type ($2);
1434 }
1435 else
1436 {
1437 AST_Decl::NodeType nt = tp->node_type ();
1439 if (nt == AST_Decl::NT_valuetype
1440 || nt == AST_Decl::NT_eventtype)
1441 {
1442 // valuetype is not allowed as <type_spec>
1443 // for boxed value
1444 idl_global->err ()->error0 (
1445 UTL_Error::EIDL_ILLEGAL_BOXED_TYPE
1446 );
1447 }
1448 else
1449 {
1450 /*
1451 * Add the valuebox to its definition scope
1452 */
1453 AST_ValueBox *vb =
1454 idl_global->gen ()->create_valuebox (&n,
1455 tp);
1456 (void) s->fe_add_valuebox (vb);
1457 }
1458 }
1459 }
1461 $1->destroy ();
1462 delete $1;
1463 $1 = 0;
1465 $$ = 0;
1466 }
1467 ;
1469 value_elements
1470 : value_elements at_least_one_annotation value_element
1471 {
1472 AST_Annotation_Appls *&annotations = $2;
1473 AST_Decls *&decls = $3;
1474 if (decls)
1475 {
1476 for (size_t i = 0; i < decls->size (); i++)
1477 {
1478 (*decls)[i]->annotation_appls (*annotations);
1479 }
1480 }
1481 else
1482 {
1483 idl_global->err ()-> unsupported_warning (
1484 "Annotating this is not supported");
1485 }
1486 delete annotations;
1487 delete decls;
1488 }
1489 | value_elements value_element
1490 {
1491 delete $2;
1492 }
1493 | %empty
1494 ;
1496 value_element
1497 : state_member
1498 | export
1499 {
1500 AST_Decl *&node = $1;
1501 AST_Decls *value = 0;
1502 if (node)
1503 {
1504 value = new AST_Decls;
1505 value->push_back (node);
1506 }
1507 $$ = value;
1508 }
1509 | init_decl
1510 {
1511 AST_Decl *&node = $1;
1512 AST_Decls *value = 0;
1513 if (node)
1514 {
1515 value = new AST_Decls;
1516 value->push_back (node);
1517 }
1518 $<decls_val>$ = value;
1519 }
1520 ';'
1521 {
1522 $$ = $<decls_val>2;
1523 }
1524 ;
1526 visibility
1527 : IDL_PUBLIC
1528 {
1529 $$ = AST_Field::vis_PUBLIC;
1530 }
1531 | IDL_PRIVATE
1532 {
1533 $$ = AST_Field::vis_PRIVATE;
1534 }
1535 ;
1537 state_member
1538 : visibility member_i
1539 {
1540 AST_Field::Visibility &visibility = $1;
1541 AST_Decls *&decls_ptr = $2;
1542 if (decls_ptr)
1543 {
1544 AST_Decls &decls = *decls_ptr;
1545 for (size_t i = 0; i < decls.size (); i++)
1546 {
1547 AST_Field *field = dynamic_cast<AST_Field *> (decls[i]);
1548 if (field)
1549 {
1550 field->visibility (visibility);
1551 }
1552 }
1553 }
1554 $$ = decls_ptr;
1555 }
1556 ;
1558 exports
1559 : at_least_one_export
1560 | %empty
1561 ;
1563 at_least_one_export
1564 : exports at_least_one_annotation export
1565 {
1566 AST_Annotation_Appls *annotations = $2;
1567 AST_Decl *d = $3;
1568 if (d)
1569 {
1570 d->annotation_appls (*annotations);
1571 }
1572 else
1573 {
1574 idl_global->err ()-> unsupported_warning (
1575 "Annotating this is not supported");
1576 }
1577 delete annotations;
1578 }
1579 | exports export
1580 ;
1582 export
1583 : type_dcl
1584 {
1585 idl_global->set_parse_state (IDL_GlobalData::PS_TypeDeclSeen);
1586 }
1587 ';'
1588 {
1589 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
1590 }
1591 | typeid_dcl
1592 {
1593 idl_global->set_parse_state (IDL_GlobalData::PS_TypeIdDeclSeen);
1594 }
1595 ';'
1596 {
1597 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
1598 }
1599 | typeprefix_dcl
1600 {
1601 idl_global->set_parse_state (IDL_GlobalData::PS_TypePrefixDeclSeen);
1602 }
1603 ';'
1604 {
1605 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
1606 }
1607 | const_dcl
1608 {
1609 idl_global->set_parse_state (IDL_GlobalData::PS_ConstDeclSeen);
1610 }
1611 ';'
1612 {
1613 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
1614 }
1615 | exception
1616 {
1617 idl_global->set_parse_state (IDL_GlobalData::PS_ExceptDeclSeen);
1618 }
1619 ';'
1620 {
1621 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
1622 }
1623 | attribute
1624 {
1625 idl_global->set_parse_state (IDL_GlobalData::PS_AttrDeclSeen);
1626 }
1627 ';'
1628 {
1629 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
1630 }
1631 | operation
1632 {
1633 idl_global->set_parse_state (IDL_GlobalData::PS_OpDeclSeen);
1634 }
1635 ';'
1636 {
1637 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
1638 }
1639 | error
1640 {
1641 idl_global->err ()->syntax_error (idl_global->parse_state ());
1642 }
1643 ';'
1644 {
1645 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
1646 yyerrok;
1647 $$ = 0;
1648 }
1649 ;
1651 at_least_one_scoped_name :
1652 scoped_name scoped_names
1653 {
1654 ACE_NEW_RETURN ($<nlval>$,
1655 UTL_NameList ($1,
1656 $2),
1657 1);
1658 }
1659 ;
1661 scoped_names
1662 : scoped_names
1663 ','
1664 {
1665 idl_global->set_parse_state (IDL_GlobalData::PS_SNListCommaSeen);
1666 }
1667 scoped_name
1668 {
1669 idl_global->set_parse_state (IDL_GlobalData::PS_ScopedNameSeen);
1671 UTL_NameList *nl = 0;
1672 ACE_NEW_RETURN (nl,
1673 UTL_NameList ($4,
1674 0),
1675 1);
1677 if ($1 == 0)
1678 {
1679 $<nlval>$ = nl;
1680 }
1681 else
1682 {
1683 $1->nconc (nl);
1684 $<nlval>$ = $1;
1685 }
1686 }
1687 | %empty
1688 {
1689 $<nlval>$ = 0;
1690 }
1691 ;
1693 scoped_name
1694 : id
1695 {
1696 idl_global->set_parse_state (IDL_GlobalData::PS_SN_IDSeen);
1698 ACE_NEW_RETURN ($$,
1699 UTL_IdList ($1,
1700 0),
1701 1);
1702 }
1703 | IDL_SCOPE_DELIMITOR
1704 {
1705 idl_global->set_parse_state (IDL_GlobalData::PS_ScopeDelimSeen);
1706 }
1707 id
1708 {
1709 idl_global->set_parse_state (IDL_GlobalData::PS_SN_IDSeen);
1711 Identifier *id = 0;
1712 ACE_NEW_RETURN (id,
1713 Identifier ($1),
1714 1);
1715 ACE::strdelete ($1);
1716 $1 = 0;
1717 UTL_IdList *sn = 0;
1718 ACE_NEW_RETURN (sn,
1719 UTL_IdList ($3,
1720 0),
1721 1);
1722 ACE_NEW_RETURN ($<idlist>$,
1723 UTL_IdList (id,
1724 sn),
1725 1);
1726 }
1727 | scoped_name
1728 IDL_SCOPE_DELIMITOR
1729 {
1730 idl_global->set_parse_state (IDL_GlobalData::PS_ScopeDelimSeen);
1732 // This cleans up all the non-global "::"s in scoped names.
1733 // If there is a global one, it gets put into the UTL_IdList,
1734 // so we clean it up in the case above.
1735 ACE::strdelete ($2);
1736 $2 = 0;
1737 }
1738 id
1739 {
1740 idl_global->set_parse_state (IDL_GlobalData::PS_SN_IDSeen);
1742 UTL_IdList *sn = 0;
1743 ACE_NEW_RETURN (sn,
1744 UTL_IdList ($4,
1745 0),
1746 1);
1747 $1->nconc (sn);
1748 $<idlist>$ = $1;
1749 }
1750 ;
1752 id : IDENTIFIER
1753 {
1754 ACE_NEW_RETURN ($$,
1755 Identifier ($1),
1756 1);
1757 ACE::strdelete ($1);
1758 $1 = 0;
1759 }
1760 ;
1762 defining_id : IDENTIFIER
1763 {
1764 /* defining_id is a defining identifier
1765 whereas id is usually a reference to a defining identifier */
1766 ACE_NEW_RETURN ($$, Identifier ($1), 1);
1767 ACE::strdelete ($1);
1768 $1 = 0;
1769 }
1770 ;
1772 interface_forward :
1773 interface_decl
1774 {
1775 UTL_Scope *s = idl_global->scopes ().top_non_null ();
1776 UTL_ScopedName n ($1, 0);
1778 if (ACE_OS::strcmp ($1->get_string (),
1779 "TypeCode") == 0
1780 && !idl_global->in_main_file ())
1781 {
1782 AST_PredefinedType *pdt =
1783 idl_global->gen ()->create_predefined_type (
1784 AST_PredefinedType::PT_pseudo,
1785 &n
1786 );
1788 s->add_to_scope (pdt);
1790 $1->destroy ();
1791 delete $1;
1792 $1 = 0;
1794 break;
1795 }
1797 AST_InterfaceFwd *f = 0;
1798 idl_global->set_parse_state (IDL_GlobalData::PS_InterfaceForwardSeen);
1800 /*
1801 * Create a node representing a forward declaration of an
1802 * interface. Store it in the enclosing scope
1803 */
1804 if (s != 0)
1805 {
1806 f = idl_global->gen ()->create_interface_fwd (&n,
1807 0,
1808 0);
1809 (void) s->fe_add_interface_fwd (f);
1810 }
1812 $1->destroy ();
1813 delete $1;
1814 $1 = 0;
1815 }
1816 |
1817 IDL_LOCAL interface_decl
1818 {
1819 UTL_Scope *s = idl_global->scopes ().top_non_null ();
1820 UTL_ScopedName n ($2,
1821 0);
1822 AST_InterfaceFwd *f = 0;
1823 idl_global->set_parse_state (
1824 IDL_GlobalData::PS_InterfaceForwardSeen
1825 );
1827 /*
1828 * Create a node representing a forward declaration of an
1829 * interface. Store it in the enclosing scope
1830 */
1831 if (s != 0)
1832 {
1833 f = idl_global->gen ()->create_interface_fwd (&n,
1834 1,
1835 0);
1836 (void) s->fe_add_interface_fwd (f);
1837 }
1839 $2->destroy ();
1840 delete $2;
1841 $2 = 0;
1842 }
1843 |
1844 IDL_ABSTRACT interface_decl
1845 {
1846 UTL_Scope *s = idl_global->scopes ().top_non_null ();
1847 UTL_ScopedName n ($2,
1848 0);
1849 AST_InterfaceFwd *f = 0;
1850 idl_global->set_parse_state (
1851 IDL_GlobalData::PS_InterfaceForwardSeen
1852 );
1854 /*
1855 * Create a node representing a forward declaration of an
1856 * interface. Store it in the enclosing scope
1857 */
1858 if (s != 0)
1859 {
1860 f = idl_global->gen ()->create_interface_fwd (&n,
1861 0,
1862 1);
1863 (void) s->fe_add_interface_fwd (f);
1864 }
1866 $2->destroy ();
1867 delete $2;
1868 $2 = 0;
1870 $$ = dynamic_cast<AST_Decl *> (f);
1871 }
1872 ;
1874 const_dcl :
1875 IDL_CONST
1876 {
1877 idl_global->set_parse_state (IDL_GlobalData::PS_ConstSeen);
1878 }
1879 const_type
1880 {
1881 idl_global->set_parse_state (IDL_GlobalData::PS_ConstTypeSeen);
1882 }
1883 defining_id
1884 {
1885 idl_global->set_parse_state (IDL_GlobalData::PS_ConstIDSeen);
1886 }
1887 '='
1888 {
1889 idl_global->set_parse_state (IDL_GlobalData::PS_ConstAssignSeen);
1890 }
1891 expression
1892 {
1893 $$ = 0;
1894 UTL_ScopedName n ($5, 0);
1896 UTL_Scope *s = idl_global->scopes ().top_non_null ();
1897 AST_Constant *c = 0;
1898 idl_global->set_parse_state (IDL_GlobalData::PS_ConstExprSeen);
1900 /*
1901 * Create a node representing a constant declaration. Store
1902 * it in the enclosing scope.
1903 */
1904 if ($9 != 0 && s != 0)
1905 {
1906 AST_Param_Holder *param_holder = $9->param_holder ();
1908 AST_Expression::AST_ExprValue *result =
1909 $9->check_and_coerce ($3, tao_enum_constant_decl);
1910 tao_enum_constant_decl = 0;
1912 // If the expression is a template parameter place
1913 // holder, 'result' will be 0, but it's ok.
1914 if (result == 0 && param_holder == 0)
1915 {
1916 idl_global->err ()->coercion_error ($9, $3);
1917 $9->destroy ();
1918 delete $9;
1919 $9 = 0;
1920 }
1921 else
1922 {
1923 AST_Expression::ExprType et = $3;
1925 if (param_holder != 0
1926 && et != param_holder->info ()->const_type_)
1927 {
1928 idl_global->err ()->mismatched_template_param (
1929 param_holder->info ()->name_.c_str ());
1930 }
1931 else
1932 {
1933 c = idl_global->gen ()->create_constant ($3, $9, &n);
1934 (void) s->fe_add_constant (c);
1935 $$ = c;
1936 }
1937 }
1939 delete result;
1940 result = 0;
1941 }
1943 $5->destroy ();
1944 delete $5;
1945 $5 = 0;
1946 }
1947 ;
1949 const_type
1950 : integer_type
1951 | char_type
1952 | octet_type
1953 | boolean_type
1954 | floating_pt_type
1955 | fixed_type
1956 | string_type_spec
1957 {
1958 $$ = AST_Expression::EV_string;
1959 }
1960 | wstring_type_spec
1961 {
1962 $$ = AST_Expression::EV_wstring;
1963 }
1964 | scoped_name
1965 {
1966 UTL_Scope *s = idl_global->scopes ().top_non_null ();
1967 AST_PredefinedType *c = 0;
1968 AST_Typedef *t = 0;
1969 UTL_ScopedName *sn = $1;
1971 /*
1972 * If the constant's type is a scoped name, it must resolve
1973 * to a scalar constant type
1974 */
1975 AST_Decl *d =
1976 s->lookup_by_name (sn);
1978 if (s != 0 && d != 0)
1979 {
1980 /*
1981 * Look through typedefs.
1982 */
1983 while (d->node_type () == AST_Decl::NT_typedef)
1984 {
1985 t = dynamic_cast<AST_Typedef*> (d);
1987 if (t == 0)
1988 {
1989 break;
1990 }
1992 d = t->base_type ();
1993 }
1995 if (d->node_type () == AST_Decl::NT_pre_defined)
1996 {
1997 c = dynamic_cast<AST_PredefinedType*> (d);
1999 $$ = FE_Utils::PredefinedTypeToExprType (c->pt ());
2000 }
2001 else if (d->node_type () == AST_Decl::NT_string)
2002 {
2003 $$ = AST_Expression::EV_string;
2004 }
2005 else if (d->node_type () == AST_Decl::NT_wstring)
2006 {
2007 $$ = AST_Expression::EV_wstring;
2008 }
2009 else if (d->node_type () == AST_Decl::NT_enum)
2010 {
2011 $$ = AST_Expression::EV_enum;
2012 tao_enum_constant_decl =
2013 dynamic_cast<AST_Enum*> (d);
2014 }
2015 else
2016 {
2017 idl_global->err ()->constant_expected (sn, d);
2018 }
2019 }
2020 else
2021 {
2022 idl_global->err ()->lookup_error (sn);
2023 }
2025 sn->destroy ();
2026 delete sn;
2027 sn = 0;
2028 $1 = 0;
2029 }
2030 ;
2032 expression : const_expr ;
2034 const_expr : or_expr ;
2036 or_expr : xor_expr
2037 | or_expr '|' xor_expr
2038 {
2039 $$ =
2040 idl_global->gen ()->create_expr (
2041 AST_Expression::EC_or,
2042 $1,
2043 $3
2044 );
2045 }
2046 ;
2048 xor_expr
2049 : and_expr
2050 | xor_expr '^' and_expr
2051 {
2052 $$ =
2053 idl_global->gen ()->create_expr (
2054 AST_Expression::EC_xor,
2055 $1,
2056 $3
2057 );
2058 }
2059 ;
2061 and_expr
2062 : shift_expr
2063 | and_expr '&' shift_expr
2064 {
2065 $$ =
2066 idl_global->gen ()->create_expr (
2067 AST_Expression::EC_and,
2068 $1,
2069 $3
2070 );
2071 }
2072 ;
2074 shift_expr
2075 : add_expr
2076 | shift_expr IDL_LEFT_SHIFT add_expr
2077 {
2078 $$ =
2079 idl_global->gen ()->create_expr (
2080 AST_Expression::EC_left,
2081 $1,
2082 $3
2083 );
2084 }
2085 | shift_expr IDL_RIGHT_SHIFT add_expr
2086 {
2087 $$ =
2088 idl_global->gen ()->create_expr (
2089 AST_Expression::EC_right,
2090 $1,
2091 $3
2092 );
2093 }
2094 ;
2096 add_expr
2097 : mult_expr
2098 | add_expr '+' mult_expr
2099 {
2100 $$ =
2101 idl_global->gen ()->create_expr (
2102 AST_Expression::EC_add,
2103 $1,
2104 $3
2105 );
2106 }
2107 | add_expr '-' mult_expr
2108 {
2109 $$ =
2110 idl_global->gen ()->create_expr (
2111 AST_Expression::EC_minus,
2112 $1,
2113 $3
2114 );
2115 }
2116 ;
2118 mult_expr
2119 : unary_expr
2120 | mult_expr '*' unary_expr
2121 {
2122 $$ =
2123 idl_global->gen ()->create_expr (
2124 AST_Expression::EC_mul,
2125 $1,
2126 $3
2127 );
2128 }
2129 | mult_expr '/' unary_expr
2130 {
2131 $$ =
2132 idl_global->gen ()->create_expr (
2133 AST_Expression::EC_div,
2134 $1,
2135 $3
2136 );
2137 }
2138 | mult_expr '%' unary_expr
2139 {
2140 $$ =
2141 idl_global->gen ()->create_expr (
2142 AST_Expression::EC_mod,
2143 $1,
2144 $3
2145 );
2146 }
2147 ;
2149 unary_expr
2150 : primary_expr
2151 | '+' primary_expr
2152 {
2153 $$ =
2154 idl_global->gen ()->create_expr (
2155 AST_Expression::EC_u_plus,
2156 $2,
2157 0
2158 );
2159 }
2160 | '-' primary_expr
2161 {
2162 $$ =
2163 idl_global->gen ()->create_expr (
2164 AST_Expression::EC_u_minus,
2165 $2,
2166 0
2167 );
2168 }
2169 | '~' primary_expr
2170 {
2171 $$ =
2172 idl_global->gen ()->create_expr (
2173 AST_Expression::EC_bit_neg,
2174 $2,
2175 0
2176 );
2177 }
2178 ;
2180 primary_expr
2181 : scoped_name
2182 {
2183 UTL_ScopedName *name = $1;
2185 /*
2186 * An expression which is a scoped name is not resolved now,
2187 * but only when it is evaluated (such as when it is assigned
2188 * as a constant value).
2189 */
2190 AST_Expression *expr = 0;
2192 AST_Decl *node = stack_based_lookup_for_primary_expr ?
2193 idl_global->scopes ().lookup_by_name (name) :
2194 idl_global->scopes ().top_non_null ()->lookup_by_name (name);
2195 if (!node)
2196 {
2197 if (!idl_global->ignore_lookup_errors_)
2198 {
2199 idl_global->err ()->lookup_error (name);
2200 return 1;
2201 }
2202 }
2203 else if (node->node_type () == AST_Decl::NT_const)
2204 {
2205 /*
2206 * If the scoped name is an IDL constant, it
2207 * may be used in an array dim, a string
2208 * bound, or a sequence bound. If so, it
2209 * must be unsigned and > 0. We assign the
2210 * constant's value and type to the
2211 * expression created here so we can check
2212 * them later.
2213 */
2214 AST_Constant *c = dynamic_cast<AST_Constant *> (node);
2215 expr = idl_global->gen ()->create_expr (
2216 c->constant_value (),
2217 c->et ());
2218 }
2219 else
2220 {
2221 // An AST_Expression owns the scoped name
2222 // passed in this constructor, so we copy it
2223 // and destroy it below no matter which case
2224 // is followed.
2225 expr = idl_global->gen ()->create_expr (name->copy ());
2226 if (node->node_type () == AST_Decl::NT_enum_val)
2227 {
2228 expr->enum_parent (
2229 dynamic_cast<AST_EnumVal *> (node)->enum_parent ());
2230 }
2231 }
2233 $<exval>$ = expr;
2234 name->destroy ();
2235 delete name;
2236 $1 = name = 0;
2237 }
2238 | literal
2239 | '(' const_expr ')'
2240 {
2241 $$ = $2;
2242 }
2243 ;
2245 literal
2246 : IDL_INTEGER_LITERAL
2247 {
2248 $$ = idl_global->gen ()->create_expr ($1);
2249 }
2250 | IDL_UINTEGER_LITERAL
2251 {
2252 $$ =
2253 idl_global->gen ()->create_expr ($1);
2254 }
2255 | IDL_STRING_LITERAL
2256 {
2257 $$ = idl_global->gen ()->create_expr ($1);
2258 $1->destroy ();
2259 delete $1;
2260 $1 = 0;
2261 }
2262 | IDL_WSTRING_LITERAL
2263 {
2264 char *wide_string = $1;
2265 $$ = idl_global->gen ()->create_expr (wide_string);
2266 ACE_OS::free (wide_string);
2267 $1 = 0;
2268 }
2269 | IDL_CHARACTER_LITERAL
2270 {
2271 $$ = idl_global->gen ()->create_expr ($1);
2272 }
2273 | IDL_WCHAR_LITERAL
2274 {
2275 ACE_OutputCDR::from_wchar wc ($1);
2276 $$ = idl_global->gen ()->create_expr (wc);
2277 }
2278 | IDL_FIXED_PT_LITERAL
2279 {
2280 $$ = idl_global->gen ()->create_expr ($1);
2281 }
2282 | IDL_FLOATING_PT_LITERAL
2283 {
2284 $$ = idl_global->gen ()->create_expr ($1);
2285 }
2286 | IDL_TRUETOK
2287 {
2288 $$ = idl_global->gen ()->create_expr (true);
2289 }
2290 | IDL_FALSETOK
2291 {
2292 $$ = idl_global->gen ()->create_expr (false);
2293 }
2294 ;
2296 positive_int_expr :
2297 const_expr
2298 {
2299 int good_expression = 1;
2300 $1->evaluate (AST_Expression::EK_positive_int);
2301 AST_Expression::AST_ExprValue *ev = $1->ev ();
2303 /*
2304 * If const_expr is an enum value (AST_EnumVal inherits from
2305 * AST_Constant), the AST_ExprValue will probably not be set,
2306 * but there's no need to check anyway
2307 */
2308 if (ev != 0)
2309 {
2310 switch (ev->et)
2311 {
2312 case AST_Expression::EV_ushort:
2313 if (ev->u.usval == 0)
2314 {
2315 good_expression = 0;
2316 }
2318 break;
2319 case AST_Expression::EV_ulong:
2320 if (ev->u.ulval == 0)
2321 {
2322 good_expression = 0;
2323 }
2325 break;
2326 case AST_Expression::EV_ulonglong:
2327 if (ev->u.ullval == 0)
2328 {
2329 good_expression = 0;
2330 }
2332 break;
2333 case AST_Expression::EV_octet:
2334 if (ev->u.oval == 0)
2335 {
2336 good_expression = 0;
2337 }
2339 break;
2340 case AST_Expression::EV_bool:
2341 if (ev->u.bval == 0)
2342 {
2343 good_expression = 0;
2344 }
2346 break;
2347 default:
2348 good_expression = 0;
2349 break;
2350 }
2351 }
2353 if (good_expression)
2354 {
2355 $$ = $1;
2356 }
2357 else
2358 {
2359 idl_global->err ()->syntax_error (idl_global->parse_state ());
2360 }
2361 }
2362 ;
2364 annotation_dcl
2365 : IDL_ANNOTATION_DECL defining_id '{'
2366 {
2367 if (idl_global->idl_version_ < IDL_VERSION_4)
2368 {
2369 idl_global->err ()->idl_version_error (
2370 "Annotations are an IDL4 feature");
2371 }
2373 Identifier *id = $2;
2374 UTL_ScopedName name (id, 0);
2375 AST_Annotation_Decl::escape_name (&name);
2376 AST_Annotation_Decl *annotation_decl = idl_global->gen ()->
2377 create_annotation_decl (&name);
2378 idl_global->scopes ().top_non_null ()->
2379 fe_add_annotation_decl (annotation_decl);
2380 idl_global->scopes ().push (annotation_decl);
2381 }
2382 annotation_body '}'
2383 {
2384 Identifier *id = $2;
2385 idl_global->scopes ().pop ();
2386 id->destroy ();
2387 delete id;
2389 $$ = 0;
2390 }
2391 ;
2393 annotation_body
2394 : annotation_body annotation_statement
2395 | %empty
2396 ;
2398 annotation_statement
2399 : annotation_member
2400 | const_dcl ';'
2401 | enum_type ';'
2402 | IDL_TYPEDEF
2403 {
2404 idl_global->set_parse_state (IDL_GlobalData::PS_TypedefSeen);
2405 idl_global->in_typedef (true);
2406 }
2407 type_declarator ';'
2408 ;
2410 annotation_member_type
2411 : const_type
2412 | any_type
2413 ;
2415 annotation_member
2416 : annotation_member_type defining_id annotation_member_default ';'
2417 {
2418 UTL_Scope *scope = idl_global->scopes ().top_non_null ();
2419 UTL_Scope *root = idl_global->scopes ().bottom ();
2421 AST_Expression::ExprType type = $1;
2422 Identifier *name = $2;
2423 // Annotation member names can't clash with C++ keywords
2424 FE_Utils::original_local_name (name);
2425 UTL_ScopedName *scoped_name = new UTL_ScopedName (name, 0);
2426 AST_Expression *default_value = $3;
2428 AST_Decl * type_obj;
2429 switch (type)
2430 {
2431 case AST_Expression::EV_string:
2432 case AST_Expression::EV_wstring:
2433 type_obj = tao_string_decl;
2434 break;
2435 case AST_Expression::EV_enum:
2436 type_obj = tao_enum_constant_decl;
2437 break;
2438 default:
2439 type_obj = root->lookup_primitive_type (type);
2440 }
2442 FE_Declarator *declarator = new FE_Declarator (
2443 scoped_name, FE_Declarator::FD_simple, 0);
2444 AST_Annotation_Member *member = idl_global->gen ()->
2445 create_annotation_member (
2446 type, declarator->compose (type_obj), declarator->name ());
2447 scope->fe_add_annotation_member (member);
2449 declarator->destroy ();
2450 delete declarator;
2452 if (default_value)
2453 {
2454 // Check if types are compatible, else report error
2455 AST_Expression::AST_ExprValue *result =
2456 default_value->check_and_coerce (type, tao_enum_constant_decl);
2457 tao_enum_constant_decl = 0;
2458 if (result)
2459 {
2460 member->value (default_value);
2461 }
2462 else
2463 {
2464 idl_global->err ()->coercion_error (default_value, type);
2465 }
2466 delete result;
2467 }
2468 }
2469 ;
2471 annotation_member_default
2472 : IDL_DEFAULT const_expr
2473 {
2474 $$ = $2;
2475 }
2476 | %empty
2477 {
2478 $$ = 0;
2479 }
2480 ;
2482 at_least_one_annotation
2483 : annotations_maybe annotation_appl
2484 {
2485 AST_Annotation_Appls *annotations = $1;
2486 AST_Annotation_Appl *annotation = $2;
2487 if (annotation)
2488 {
2489 annotations->add (annotation);
2490 }
2491 $$ = annotations;
2492 }
2493 ;
2495 annotations_maybe
2496 : annotations_maybe annotation_appl
2497 {
2498 AST_Annotation_Appls *annotations = $1;
2499 AST_Annotation_Appl *annotation = $2;
2500 if (annotation)
2501 {
2502 annotations->add (annotation);
2503 }
2504 $$ = annotations;
2505 }
2506 | %empty
2507 {
2508 $$ = new AST_Annotation_Appls ();
2509 }
2510 ;
2512 annotation_appl
2513 : IDL_ANNOTATION_SYMBOL scoped_name
2514 {
2515 if (idl_global->idl_version_ < IDL_VERSION_4)
2516 {
2517 idl_global->err ()->idl_version_error (
2518 "Annotations are an IDL4 feature");
2519 }
2521 AST_Annotation_Decl *decl = 0;
2522 UTL_ScopedName *name = $2;
2523 AST_Annotation_Decl::escape_name (name);
2525 // Check for Matching Annotation Declaration
2526 AST_Decl *d = idl_global->scopes ().top_non_null ()->
2527 lookup_by_name (name);
2528 if (d)
2529 {
2530 decl = dynamic_cast<AST_Annotation_Decl*> (d);
2531 if (decl)
2532 {
2533 idl_global->scopes ().push (decl);
2534 }
2535 }
2536 else
2537 {
2538 Identifier &id = *name->last_component ();
2539 switch (idl_global->unknown_annotations_)
2540 {
2541 default:
2542 case IDL_GlobalData::UNKNOWN_ANNOTATIONS_WARN_ONCE:
2543 if (idl_global->unknown_annotations_seen_.insert (id) == 1)
2544 {
2545 break;
2546 }
2547 idl_global->err ()->lookup_warning (name);
2548 break;
2549 case IDL_GlobalData::UNKNOWN_ANNOTATIONS_WARN_ALL:
2550 idl_global->err ()->lookup_warning (name);
2551 break;
2552 case IDL_GlobalData::UNKNOWN_ANNOTATIONS_ERROR:
2553 idl_global->err ()->lookup_error (name);
2554 break;
2555 case IDL_GlobalData::UNKNOWN_ANNOTATIONS_IGNORE:
2556 break;
2557 }
2559 /*
2560 * Ignore lookup errors for parameter values that might depend on
2561 * constants or enums from the missing annotation declaration.
2562 */
2563 idl_global->ignore_lookup_errors_ = true;
2564 }
2566 stack_based_lookup_for_primary_expr = true;
2568 $<annotation_decl_val>$ = decl;
2569 }
2570 annotation_appl_params_maybe
2571 {
2572 idl_global->ignore_lookup_errors_ = false;
2573 stack_based_lookup_for_primary_expr = false;
2574 AST_Annotation_Appl *appl = 0;
2575 UTL_ScopedName *name = $2;
2576 AST_Annotation_Decl *decl = $<annotation_decl_val>3;
2577 AST_Annotation_Appl::Params *params = $4;
2579 if (decl)
2580 {
2581 appl = idl_global->gen ()->create_annotation_appl (name, params);
2582 appl->apply_from (decl);
2583 idl_global->scopes ().pop ();
2584 }
2585 else
2586 {
2587 AST_Annotation_Appl::delete_params (params);
2588 }
2590 if (name)
2591 {
2592 name->destroy ();
2593 delete name;
2594 }
2596 $$ = appl;
2597 }
2598 ;
2600 annotation_appl_params_maybe
2601 : '(' annotation_appl_params ')'
2602 {
2603 $$ = $2;
2604 }
2605 | %empty
2606 {
2607 $$ = 0;
2608 }
2609 ;
2611 annotation_appl_params
2612 : const_expr
2613 {
2614 AST_Annotation_Appl::Params *params = new AST_Annotation_Appl::Params;
2615 AST_Annotation_Appl::Param *param = new AST_Annotation_Appl::Param;
2616 param->id = 0;
2617 param->expr = $1;
2618 params->push (param);
2619 $$ = params;
2620 }
2621 | named_annotation_appl_params
2622 {
2623 $$ = $1;
2624 }
2625 ;
2627 named_annotation_appl_params
2628 : named_annotation_appl_param more_named_annotation_appl_params
2629 {
2630 AST_Annotation_Appl::Params *params = $2;
2631 params->push ($1);
2632 $$ = params;
2633 }
2635 more_named_annotation_appl_params
2636 : ',' named_annotation_appl_param more_named_annotation_appl_params
2637 {
2638 AST_Annotation_Appl::Params *params = $3;
2639 params->push ($2);
2640 $$ = params;
2641 }
2642 | %empty
2643 {
2644 $$ = new AST_Annotation_Appl::Params;
2645 }
2646 ;
2648 named_annotation_appl_param
2649 : id '=' const_expr
2650 {
2651 AST_Annotation_Appl::Param *param = new AST_Annotation_Appl::Param;
2652 param->id = $1;
2653 // Annotation Member Names Can't Clash with C++ keywords
2654 FE_Utils::original_local_name (param->id);
2655 param->expr = $3;
2656 $$ = param;
2657 }
2658 ;
2660 type_dcl
2661 : IDL_TYPEDEF
2662 {
2663 idl_global->set_parse_state (IDL_GlobalData::PS_TypedefSeen);
2664 idl_global->in_typedef (true);
2665 }
2666 type_declarator
2667 {
2668 $$ = $3;
2669 }
2670 | struct_type
2671 {
2672 $$ = $1;
2673 }
2674 | union_type
2675 {
2676 $$ = $1;
2677 }
2678 | enum_type
2679 {
2680 $$ = $1;
2681 }
2682 | IDL_NATIVE simple_declarator
2683 {
2684 UTL_Scope *s = idl_global->scopes ().top_non_null ();
2685 AST_Native *node = 0;
2686 idl_global->set_parse_state (IDL_GlobalData::PS_NativeSeen);
2688 /*
2689 * Create a node representing a Native and add it to its
2690 * enclosing scope
2691 */
2692 if (s != 0)
2693 {
2694 node =
2695 idl_global->gen ()->create_native (
2696 $2->name ()
2697 );
2698 /*
2699 * Add it to its defining scope
2700 */
2701 (void) s->fe_add_native (node);
2702 }
2704 $2->destroy ();
2705 delete $2;
2706 $2 = 0;
2708 $$ = 0;
2709 }
2710 | constructed_forward_type_spec
2711 {
2712 $$ = 0;
2713 }
2714 ;
2716 type_declarator :
2717 type_spec
2718 {
2719 idl_global->set_parse_state (IDL_GlobalData::PS_TypeSpecSeen);
2720 }
2721 at_least_one_declarator
2722 {
2723 AST_Decl *type_spec = $1;
2724 UTL_DeclList *decls = $3;
2726 UTL_Scope *s = idl_global->scopes ().top_non_null ();
2727 FE_Declarator *d = 0;
2728 AST_Typedef *t = 0;
2729 unsigned long index = 0UL;
2730 idl_global->set_parse_state (IDL_GlobalData::PS_DeclaratorsSeen);
2732 /*
2733 * Create a list of type renamings. Add them to the
2734 * enclosing scope
2735 */
2736 if (s && type_spec && decls)
2737 {
2738 for (UTL_DecllistActiveIterator l (decls); !l.is_done (); l.next ())
2739 {
2740 d = l.item ();
2741 if (d == 0)
2742 {
2743 continue;
2744 }
2746 AST_Type *tp = d->compose (type_spec);
2747 if (tp == 0)
2748 {
2749 continue;
2750 }
2752 if (AST_Decl::NT_except == tp->node_type ())
2753 {
2754 idl_global->err ()->not_a_type (tp);
2755 continue;
2756 }
2758 t = idl_global->gen ()->create_typedef (tp,
2759 d->name (),
2760 s->is_local (),
2761 s->is_abstract ());
2763 // If the base type is a sequence or array, the typedef
2764 // constructor sets owns_base_type_ to true. But if
2765 // there is a comma-separated list of such typedefs,
2766 // the base type can be destroyed only once. In all
2767 // other cases, the line below has no effect.
2768 if (index++ > 0)
2769 {
2770 t->owns_base_type (false);
2771 }
2773 (void) s->fe_add_typedef (t);
2774 idl_global->in_typedef (false);
2775 }
2777 // This FE_Declarator class isn't destroyed with the AST.
2778 decls->destroy ();
2779 delete decls;
2780 $3 = decls = 0;
2781 }
2783 $$ = t;
2784 }
2785 ;
2787 type_spec
2788 : simple_type_spec
2789 | constructed_type_spec
2790 ;
2792 simple_type_spec
2793 : base_type_spec
2794 {
2795 $$ =
2796 idl_global->scopes ().bottom ()->lookup_primitive_type (
2797 $1
2798 );
2799 }
2800 | template_type_spec
2801 | scoped_name
2802 {
2803 UTL_Scope *s = idl_global->scopes ().top_non_null ();
2804 AST_Decl *d = 0;
2806 if (s != 0)
2807 {
2808 d =
2809 s->lookup_by_name ($1);
2810 }
2812 if (d == 0)
2813 {
2814 idl_global->err ()->lookup_error ($1);
2815 }
2816 else
2817 {
2818 d->last_referenced_as ($1);
2819 }
2822 $$ = d;
2823 }
2824 ;
2826 base_type_spec
2827 : integer_type
2828 | floating_pt_type
2829 | char_type
2830 | boolean_type
2831 | octet_type
2832 | fixed_type
2833 | any_type
2834 | object_type
2835 ;
2837 template_type_spec
2838 : sequence_type_spec
2839 | string_type_spec
2840 | wstring_type_spec
2841 | fixed_type_spec
2842 | map_type_spec
2843 ;
2845 constructed_type_spec
2846 : struct_type
2847 | union_type
2848 | enum_type
2849 ;
2851 constructed_forward_type_spec
2852 : struct_forward_type
2853 | union_forward_type
2854 ;
2856 at_least_one_declarator :
2857 declarator declarators
2858 {
2859 ACE_NEW_RETURN ($$,
2860 UTL_DeclList ($1,
2861 $2),
2862 1);
2863 }
2864 ;
2866 declarators
2867 : declarators
2868 ','
2869 {
2870 idl_global->set_parse_state (IDL_GlobalData::PS_DeclsCommaSeen);
2871 }
2872 declarator
2873 {
2874 idl_global->set_parse_state (IDL_GlobalData::PS_DeclsDeclSeen);
2876 UTL_DeclList *dl = 0;
2877 ACE_NEW_RETURN (dl,
2878 UTL_DeclList ($4,
2879 0),
2880 1);
2882 if ($1 == 0)
2883 {
2884 $<dlval>$ = dl;
2885 }
2886 else
2887 {
2888 $1->nconc (dl);
2889 $<dlval>$ = $1;
2890 }
2891 }
2892 | %empty
2893 {
2894 $<dlval>$ = 0;
2895 }
2896 ;
2898 declarator
2899 : simple_declarator
2900 | complex_declarator
2901 ;
2903 at_least_one_simple_declarator :
2904 simple_declarator simple_declarators
2905 {
2906 ACE_NEW_RETURN ($<dlval>$,
2907 UTL_DeclList ($1,
2908 $2),
2909 1);
2910 }
2911 ;
2913 simple_declarators
2914 : simple_declarators
2915 ','
2916 {
2917 idl_global->set_parse_state (IDL_GlobalData::PS_DeclsCommaSeen);
2918 }
2919 simple_declarator
2920 {
2921 idl_global->set_parse_state (IDL_GlobalData::PS_DeclsDeclSeen);
2923 UTL_DeclList *dl = 0;
2924 ACE_NEW_RETURN (dl,
2925 UTL_DeclList ($4,
2926 0),
2927 1);
2929 if ($1 == 0)
2930 {
2931 $<dlval>$ = dl;
2932 }
2933 else
2934 {
2935 $1->nconc (dl);
2936 $<dlval>$ = $1;
2937 }
2938 }
2939 | %empty
2940 {
2941 $<dlval>$ = 0;
2942 }
2943 ;
2945 simple_declarator :
2946 defining_id
2947 {
2948 UTL_ScopedName *sn = 0;
2949 ACE_NEW_RETURN (sn,
2950 UTL_ScopedName ($1,
2951 0),
2952 1);
2953 ACE_NEW_RETURN ($<deval>$,
2954 FE_Declarator (sn,
2955 FE_Declarator::FD_simple,
2956 0),
2957 1);
2958 }
2959 ;
2961 complex_declarator :
2962 array_declarator
2963 {
2964 UTL_ScopedName *sn = 0;
2965 ACE_NEW_RETURN (sn,
2966 UTL_ScopedName (
2967 $1->local_name ()->copy (),
2968 0
2969 ),
2970 1);
2971 ACE_NEW_RETURN ($<deval>$,
2972 FE_Declarator (sn,
2973 FE_Declarator::FD_complex,
2974 $1),
2975 1);
2976 }
2977 ;
2979 integer_type
2980 : signed_int
2981 | unsigned_int
2982 ;
2984 signed_int
2985 : IDL_LONG
2986 {
2987 $$ = AST_Expression::EV_long;
2988 }
2989 | IDL_LONG IDL_LONG
2990 {
2991 $$ = AST_Expression::EV_longlong;
2992 }
2993 | IDL_SHORT
2994 {
2995 $$ = AST_Expression::EV_short;
2996 }
2997 | IDL_INT8
2998 {
2999 $$ = AST_Expression::EV_int8;
3000 }
3001 | IDL_INT16
3002 {
3003 $$ = AST_Expression::EV_short;
3004 }
3005 | IDL_INT32
3006 {
3007 $$ = AST_Expression::EV_long;
3008 }
3009 | IDL_INT64
3010 {
3011 $$ = AST_Expression::EV_longlong;
3012 }
3013 ;
3015 unsigned_int
3016 : IDL_UNSIGNED IDL_LONG
3017 {
3018 $$ = AST_Expression::EV_ulong;
3019 }
3020 | IDL_UNSIGNED IDL_LONG IDL_LONG
3021 {
3022 $$ = AST_Expression::EV_ulonglong;
3023 }
3024 | IDL_UNSIGNED IDL_SHORT
3025 {
3026 $$ = AST_Expression::EV_ushort;
3027 }
3028 | IDL_UINT8
3029 {
3030 $$ = AST_Expression::EV_uint8;
3031 }
3032 | IDL_UINT16
3033 {
3034 $$ = AST_Expression::EV_ushort;
3035 }
3036 | IDL_UINT32
3037 {
3038 $$ = AST_Expression::EV_ulong;
3039 }
3040 | IDL_UINT64
3041 {
3042 $$ = AST_Expression::EV_ulonglong;
3043 }
3044 ;
3046 floating_pt_type
3047 : IDL_DOUBLE
3048 {
3049 $$ = AST_Expression::EV_double;
3050 }
3051 | IDL_FLOAT
3052 {
3053 $$ = AST_Expression::EV_float;
3054 }
3055 | IDL_LONG IDL_DOUBLE
3056 {
3057 $$ = AST_Expression::EV_longdouble;
3058 }
3059 ;
3061 fixed_type
3062 : IDL_FIXED
3063 {
3064 $$ = AST_Expression::EV_fixed;
3065 }
3066 ;
3068 char_type
3069 : IDL_CHAR
3070 {
3071 $$ = AST_Expression::EV_char;
3072 }
3073 | IDL_WCHAR
3074 {
3075 $$ = AST_Expression::EV_wchar;
3076 }
3077 ;
3079 octet_type
3080 : IDL_OCTET
3081 {
3082 $$ = AST_Expression::EV_octet;
3083 }
3084 ;
3086 boolean_type
3087 : IDL_BOOLEAN
3088 {
3089 $$ = AST_Expression::EV_bool;
3090 }
3091 ;
3093 any_type
3094 : IDL_ANY
3095 {
3096 $$ = AST_Expression::EV_any;
3097 }
3098 ;
3100 object_type
3101 : IDL_OBJECT
3102 {
3103 $$ = AST_Expression::EV_object;
3104 }
3105 ;
3107 struct_decl :
3108 IDL_STRUCT
3109 {
3110 idl_global->set_parse_state (IDL_GlobalData::PS_StructSeen);
3111 }
3112 defining_id
3113 {
3114 idl_global->set_parse_state (IDL_GlobalData::PS_StructIDSeen);
3115 $$ = $3;
3116 }
3117 ;
3120 struct_type
3121 : struct_decl
3122 {
3123 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3124 UTL_ScopedName n ($1, 0);
3125 AST_Structure *d = 0;
3127 /*
3128 * Create a node representing a struct declaration. Add it
3129 * to the enclosing scope
3130 */
3131 if (s != 0)
3132 {
3133 d =
3134 idl_global->gen ()->create_structure (
3135 &n,
3136 s->is_local (),
3137 s->is_abstract ()
3138 );
3139 AST_Structure::fwd_redefinition_helper (d, s);
3140 (void) s->fe_add_structure (d);
3141 }
3143 /*
3144 * Push the scope of the struct on the scopes stack.
3145 */
3146 idl_global->scopes ().push (d);
3148 $1->destroy ();
3149 delete $1;
3150 $1 = 0;
3151 }
3152 '{'
3153 {
3154 idl_global->set_parse_state (IDL_GlobalData::PS_StructSqSeen);
3155 }
3156 at_least_one_member
3157 {
3158 idl_global->set_parse_state (IDL_GlobalData::PS_StructBodySeen);
3159 }
3160 '}'
3161 {
3162 idl_global->set_parse_state (IDL_GlobalData::PS_StructQsSeen);
3164 /*
3165 * Done with this struct. Pop its scope off the scopes stack.
3166 */
3167 $$ = dynamic_cast<AST_Structure*> (
3168 idl_global->scopes ().top_non_null ()
3169 );
3170 idl_global->scopes ().pop ();
3171 }
3172 ;
3174 at_least_one_member : member members ;
3176 members
3177 : members member
3178 | %empty
3179 ;
3181 member
3182 : annotations_maybe member_i
3183 {
3184 AST_Annotation_Appls *annotations = $1;
3185 AST_Decls *members = $2;
3186 if (annotations && members)
3187 {
3188 for (size_t i = 0; i < members->size (); i++)
3189 {
3190 (*members)[i]->annotation_appls (*annotations);
3191 }
3192 }
3193 delete annotations;
3194 delete members;
3195 }
3196 ;
3198 member_i :
3199 type_spec
3200 {
3201 idl_global->set_parse_state (IDL_GlobalData::PS_MemberTypeSeen);
3202 }
3203 at_least_one_declarator
3204 {
3205 idl_global->set_parse_state (IDL_GlobalData::PS_MemberDeclsSeen);
3206 }
3207 ';'
3208 {
3209 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3210 FE_Declarator *d = 0;
3211 AST_Field *f = 0;
3212 idl_global->set_parse_state (IDL_GlobalData::PS_MemberDeclsCompleted);
3213 AST_Decls *members = 0;
3215 /*
3216 * Check for illegal recursive use of type.
3217 */
3218 if ($1 != 0
3219 && AST_illegal_recursive_type ($1))
3220 {
3221 idl_global->err ()->error1 (UTL_Error::EIDL_RECURSIVE_TYPE,
3222 $1);
3223 }
3224 /*
3225 * Create a node representing a struct or exception member
3226 * Add it to the enclosing scope.
3227 */
3228 else if (s && $1 && $3)
3229 {
3230 members = new AST_Decls;
3231 for (UTL_DecllistActiveIterator l ($3);
3232 !l.is_done ();
3233 l.next ())
3234 {
3235 d = l.item ();
3237 if (d == 0)
3238 {
3239 continue;
3240 }
3242 AST_Type *tp = d->compose ($1);
3244 if (tp == 0)
3245 {
3246 continue;
3247 }
3249 f = idl_global->gen ()->create_field (tp, d->name ());
3250 members->push_back (f);
3251 (void) s->fe_add_field (f);
3252 }
3253 }
3255 $3->destroy ();
3256 delete $3;
3257 $3 = 0;
3259 $$ = members;
3260 }
3261 | error
3262 {
3263 idl_global->err ()->syntax_error (idl_global->parse_state ());
3264 }
3265 ';'
3266 {
3267 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
3268 yyerrok;
3269 }
3270 ;
3272 union_decl :
3273 IDL_UNION
3274 {
3275 idl_global->set_parse_state (IDL_GlobalData::PS_UnionSeen);
3276 }
3277 defining_id
3278 {
3279 idl_global->set_parse_state (IDL_GlobalData::PS_UnionIDSeen);
3280 $$ = $3;
3281 }
3282 ;
3284 union_type
3285 : union_decl IDL_SWITCH
3286 {
3287 idl_global->set_parse_state (IDL_GlobalData::PS_SwitchSeen);
3288 }
3289 '('
3290 {
3291 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3292 UTL_ScopedName n ($1, 0);
3293 AST_Union *u = 0;
3294 idl_global->set_parse_state (IDL_GlobalData::PS_SwitchOpenParSeen);
3296 /*
3297 * Create a node representing an empty union. Add it to its enclosing
3298 * scope.
3299 */
3300 if (s != 0)
3301 {
3302 u = idl_global->gen ()->create_union (0,
3303 &n,
3304 s->is_local (),
3305 s->is_abstract ());
3307 AST_Structure *st = dynamic_cast<AST_Structure*> (u);
3308 AST_Structure::fwd_redefinition_helper (st, s);
3309 u = dynamic_cast<AST_Union*> (st);
3310 (void) s->fe_add_union (u);
3311 }
3313 /*
3314 * Push the scope of the union on the scopes stack
3315 */
3316 idl_global->scopes ().push (u);
3318 /*
3319 * Don't delete $1 yet; we'll need it a bit later.
3320 */
3321 }
3322 annotations_maybe switch_type_spec
3323 {
3324 idl_global->set_parse_state (IDL_GlobalData::PS_SwitchTypeSeen);
3325 }
3326 ')'
3327 {
3328 /*
3329 * The top of the scopes must be an empty union we added after we
3330 * encountered 'union <id> switch ('. Now we are ready to add a
3331 * correct one. Temporarily remove the top so that we setup the
3332 * correct union in a right scope.
3333 */
3334 UTL_Scope *top = idl_global->scopes ().top_non_null ();
3335 idl_global->scopes ().pop ();
3336 AST_Annotation_Appls *disc_annotations = $6;
3338 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3339 UTL_ScopedName n ($1, 0);
3340 idl_global->set_parse_state (IDL_GlobalData::PS_SwitchCloseParSeen);
3342 /*
3343 * Create a node representing a union.
3344 */
3345 if ($7 != 0 && s != 0)
3346 {
3347 AST_ConcreteType *tp =
3348 dynamic_cast<AST_ConcreteType*> ($7);
3350 if (tp == 0)
3351 {
3352 idl_global->err ()->not_a_type ($7);
3353 }
3354 else
3355 {
3356 /* Create a union with a correct discriminator. */
3357 AST_Union *u = 0;
3358 u = idl_global->gen ()->create_union (tp,
3359 &n,
3360 s->is_local (),
3361 s->is_abstract ());
3363 /* Narrow the enclosing scope. */
3364 AST_Union *e = dynamic_cast<AST_Union*> (top);
3366 e->redefine (u);
3367 e->disc_annotations (*disc_annotations); // Set Discriminator Annotations
3369 u->destroy ();
3370 delete u;
3371 }
3372 }
3374 /*
3375 * Restore the top.
3376 */
3377 idl_global->scopes ().push (top);
3379 $1->destroy ();
3380 delete $1;
3381 $1 = 0;
3383 delete disc_annotations;
3384 }
3385 '{'
3386 {
3387 idl_global->set_parse_state (IDL_GlobalData::PS_UnionSqSeen);
3388 }
3389 at_least_one_case_branch
3390 {
3391 idl_global->set_parse_state (IDL_GlobalData::PS_UnionBodySeen);
3392 }
3393 '}'
3394 {
3395 idl_global->set_parse_state (IDL_GlobalData::PS_UnionQsSeen);
3397 /*
3398 * Done with this union. Pop its scope from the scopes stack.
3399 */
3400 $$ = dynamic_cast<AST_Union*> (
3401 idl_global->scopes ().top_non_null ()
3402 );
3404 if ($$ != 0)
3405 {
3406 idl_global->scopes ().pop ();
3407 }
3408 }
3409 ;
3411 switch_type_spec :
3412 integer_type
3413 {
3414 $$ =
3415 idl_global->scopes ().bottom ()->lookup_primitive_type (
3416 $1
3417 );
3418 }
3419 | char_type
3420 {
3421 /* wchars are not allowed. */
3422 if ($1 == AST_Expression::EV_wchar)
3423 {
3424 idl_global->err ()->error0 (UTL_Error::EIDL_DISC_TYPE);
3425 }
3427 $$ =
3428 idl_global->scopes ().bottom ()->lookup_primitive_type (
3429 $1
3430 );
3431 }
3432 | octet_type
3433 {
3434 /* octets are not allowed. */
3435 idl_global->err ()->error0 (UTL_Error::EIDL_DISC_TYPE);
3436 $$ =
3437 idl_global->scopes ().bottom ()->lookup_primitive_type (
3438 $1
3439 );
3440 }
3441 | boolean_type
3442 {
3443 $$ =
3444 idl_global->scopes ().bottom ()->lookup_primitive_type (
3445 $1
3446 );
3447 }
3448 | enum_type
3449 | scoped_name
3450 {
3451 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3452 AST_Decl *d = 0;
3453 AST_PredefinedType *p = 0;
3454 AST_Typedef *t = 0;
3455 bool found = false;
3457 /*
3458 * The discriminator is a scoped name. Try to resolve to
3459 * one of the scalar types or to an enum. Thread through
3460 * typedef's to arrive at the base type at the end of the
3461 * chain.
3462 */
3463 d =
3464 s->lookup_by_name ($1);
3466 if (s != 0 && d != 0)
3467 {
3468 while (!found)
3469 {
3470 switch (d->node_type ())
3471 {
3472 case AST_Decl::NT_enum:
3473 $$ = d;
3474 found = true;
3475 break;
3476 case AST_Decl::NT_pre_defined:
3477 p = dynamic_cast<AST_PredefinedType*> (d);
3479 if (p != 0)
3480 {
3481 switch (p->pt ())
3482 {
3483 case AST_PredefinedType::PT_long:
3484 case AST_PredefinedType::PT_ulong:
3485 case AST_PredefinedType::PT_longlong:
3486 case AST_PredefinedType::PT_ulonglong:
3487 case AST_PredefinedType::PT_short:
3488 case AST_PredefinedType::PT_ushort:
3489 case AST_PredefinedType::PT_char:
3490 case AST_PredefinedType::PT_boolean:
3491 $$ = p;
3492 found = true;
3493 break;
3494 case AST_PredefinedType::PT_wchar:
3495 case AST_PredefinedType::PT_octet:
3496 /* octets and wchars are not allowed */
3497 idl_global->err ()->error0 (
3498 UTL_Error::EIDL_DISC_TYPE
3499 );
3500 $$ = 0;
3501 found = true;
3502 break;
3503 default:
3504 $$ = 0;
3505 found = true;
3506 break;
3507 }
3508 }
3509 else
3510 {
3511 $$ = 0;
3512 found = true;
3513 }
3515 break;
3516 case AST_Decl::NT_typedef:
3517 t = dynamic_cast<AST_Typedef*> (d);
3519 if (t != 0)
3520 {
3521 d = t->base_type ();
3522 }
3524 break;
3525 default:
3526 $$ = 0;
3527 found = true;
3528 break;
3529 }
3530 }
3531 }
3532 else
3533 {
3534 $$ = 0;
3535 }
3537 if ($$ == 0)
3538 {
3539 idl_global->err ()->lookup_error ($1);
3541 $1->destroy ();
3542 delete $1;
3543 $1 = 0;
3545 /* If we don't return here, we'll crash later.*/
3546 if (!idl_global->ignore_lookup_errors_)
3547 {
3548 return 1;
3549 }
3550 }
3552 $1->destroy ();
3553 delete $1;
3554 $1 = 0;
3555 }
3556 ;
3558 at_least_one_case_branch : case_branch case_branches ;
3560 case_branches
3561 : case_branches case_branch
3562 | %empty
3563 ;
3565 case_branch :
3566 at_least_one_case_label
3567 {
3568 idl_global->set_parse_state (IDL_GlobalData::PS_UnionLabelSeen);
3569 }
3570 annotations_maybe element_spec
3571 {
3572 idl_global->set_parse_state (IDL_GlobalData::PS_UnionElemSeen);
3573 }
3574 ';'
3575 {
3576 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3577 AST_UnionBranch *b = 0;
3578 AST_Annotation_Appls *annotations = $3;
3579 AST_Field *f = $4;
3580 idl_global->set_parse_state (IDL_GlobalData::PS_UnionElemCompleted);
3582 /*
3583 * Create several nodes representing branches of a union.
3584 * Add them to the enclosing scope (the union scope)
3585 */
3586 if (s != 0 && $1 != 0 && $4 != 0)
3587 {
3588 b =
3589 idl_global->gen ()->create_union_branch (
3590 $1,
3591 f->field_type (),
3592 f->name ()
3593 );
3594 b->annotation_appls (*annotations);
3595 (void) s->fe_add_union_branch (b);
3597 // f has passed its field type to the union branch,
3598 // but the rest still needs to be cleaned up.
3599 f->AST_Decl::destroy ();
3600 delete f;
3601 f = 0;
3602 }
3604 delete annotations;
3605 }
3606 | error
3607 {
3608 idl_global->err ()->syntax_error (idl_global->parse_state ());
3609 }
3610 ';'
3611 {
3612 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
3613 yyerrok;
3614 }
3615 ;
3617 at_least_one_case_label :
3618 case_label case_labels
3619 {
3620 ACE_NEW_RETURN ($<llval>$,
3621 UTL_LabelList ($1,
3622 $2),
3623 1);
3624 }
3625 ;
3627 case_labels
3628 : case_labels case_label
3629 {
3630 UTL_LabelList *ll = 0;
3631 ACE_NEW_RETURN (ll,
3632 UTL_LabelList ($2,
3633 0),
3634 1);
3636 if ($1 == 0)
3637 {
3638 $<llval>$ = ll;
3639 }
3640 else
3641 {
3642 $1->nconc (ll);
3643 $<llval>$ = $1;
3644 }
3645 }
3646 | %empty
3647 {
3648 $<llval>$ = 0;
3649 }
3650 ;
3652 case_label
3653 : IDL_DEFAULT
3654 {
3655 idl_global->set_parse_state (IDL_GlobalData::PS_DefaultSeen);
3656 }
3657 ':'
3658 {
3659 idl_global->set_parse_state (IDL_GlobalData::PS_LabelColonSeen);
3661 $$ = idl_global->gen ()->create_union_label (
3662 AST_UnionLabel::UL_default,
3663 0
3664 );
3665 }
3666 | IDL_CASE
3667 {
3668 idl_global->set_parse_state (IDL_GlobalData::PS_CaseSeen);
3669 }
3670 const_expr
3671 {
3672 idl_global->set_parse_state (IDL_GlobalData::PS_LabelExprSeen);
3673 }
3674 ':'
3675 {
3676 idl_global->set_parse_state (IDL_GlobalData::PS_LabelColonSeen);
3678 $$ = idl_global->gen ()->create_union_label (
3679 AST_UnionLabel::UL_label,
3680 $3
3681 );
3682 }
3683 ;
3685 element_spec :
3686 type_spec
3687 {
3688 idl_global->set_parse_state (IDL_GlobalData::PS_UnionElemTypeSeen);
3689 }
3690 declarator
3691 {
3692 idl_global->set_parse_state (IDL_GlobalData::PS_UnionElemDeclSeen);
3694 /*
3695 * Check for illegal recursive use of type
3696 */
3697 if ($1 != 0
3698 && AST_illegal_recursive_type ($1))
3699 {
3700 idl_global->err ()->error1 (UTL_Error::EIDL_RECURSIVE_TYPE, $1);
3702 $$ = 0;
3703 }
3704 /*
3705 * Create a field in a union branch
3706 */
3707 else if ($1 == 0
3708 || $3 == 0)
3709 {
3710 $$ = 0;
3711 }
3712 else
3713 {
3714 AST_Type *tp = $3->compose ($1);
3716 if (tp == 0)
3717 {
3718 $$ = 0;
3719 }
3720 else
3721 {
3722 $$ = idl_global->gen ()->create_field (
3723 tp,
3724 $3->name ()
3725 );
3726 }
3728 $3->destroy ();
3729 delete $3;
3730 $3 = 0;
3731 }
3732 }
3733 ;
3735 struct_forward_type
3736 : struct_decl
3737 {
3738 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3739 UTL_ScopedName n ($1,
3740 0);
3741 AST_StructureFwd *d = 0;
3743 /*
3744 * Create a node representing a forward declaration of a struct.
3745 */
3746 if (s != 0)
3747 {
3748 d = idl_global->gen ()->create_structure_fwd (&n);
3749 (void) s->fe_add_structure_fwd (d);
3750 }
3752 $1->destroy ();
3753 delete $1;
3754 $1 = 0;
3756 $$ = d;
3757 }
3758 ;
3760 union_forward_type
3761 : union_decl
3762 {
3763 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3764 UTL_ScopedName n ($1,
3765 0);
3766 AST_UnionFwd *u = 0;
3768 /*
3769 * Create a node representing a forward declaration of a union.
3770 */
3771 if (s != 0)
3772 {
3773 u = idl_global->gen ()->create_union_fwd (&n);
3774 (void) s->fe_add_union_fwd (u);
3775 }
3777 $1->destroy ();
3778 delete $1;
3779 $1 = 0;
3780 }
3781 ;
3783 enum_type :
3784 IDL_ENUM
3785 {
3786 idl_global->set_parse_state (IDL_GlobalData::PS_EnumSeen);
3787 }
3788 defining_id
3789 {
3790 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3791 UTL_ScopedName n ($3, 0);
3792 AST_Enum *e = 0;
3793 idl_global->set_parse_state (IDL_GlobalData::PS_EnumIDSeen);
3795 /*
3796 * Create a node representing an enum and add it to its
3797 * enclosing scope.
3798 */
3799 if (s != 0)
3800 {
3801 e = idl_global->gen ()->create_enum (&n,
3802 s->is_local (),
3803 s->is_abstract ());
3804 /*
3805 * Add it to its defining scope
3806 */
3807 (void) s->fe_add_enum (e);
3808 }
3810 /*
3811 * Push the enum scope on the scopes stack.
3812 */
3813 idl_global->scopes ().push (e);
3815 $3->destroy ();
3816 delete $3;
3817 $3 = 0;
3818 }
3819 '{'
3820 {
3821 idl_global->set_parse_state (IDL_GlobalData::PS_EnumSqSeen);
3822 }
3823 at_least_one_enumerator
3824 {
3825 idl_global->set_parse_state (IDL_GlobalData::PS_EnumBodySeen);
3826 }
3827 '}'
3828 {
3829 idl_global->set_parse_state (IDL_GlobalData::PS_EnumQsSeen);
3831 /*
3832 * Done with this enum. Pop its scope from the scopes stack.
3833 */
3834 if (idl_global->scopes ().top () == 0)
3835 {
3836 $$ = 0;
3837 }
3838 else
3839 {
3840 $$ = dynamic_cast<AST_Enum*> (
3841 idl_global->scopes ().top_non_null ()
3842 );
3843 idl_global->scopes ().pop ();
3844 }
3845 }
3846 ;
3848 at_least_one_enumerator : enumerator enumerators ;
3850 enumerators
3851 : enumerators
3852 ','
3853 {
3854 idl_global->set_parse_state (IDL_GlobalData::PS_EnumCommaSeen);
3855 }
3856 enumerator
3857 | %empty
3858 ;
3860 enumerator :
3861 annotations_maybe IDENTIFIER
3862 {
3863 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3864 AST_Annotation_Appls *annotations = $1;
3865 Identifier id ($2);
3866 ACE::strdelete ($2);
3867 $2 = 0;
3868 UTL_ScopedName n (&id, 0);
3869 AST_EnumVal *e = 0;
3870 AST_Enum *c = 0;
3872 /*
3873 * Create a node representing one enumerator in an enum
3874 * Add it to the enclosing scope (the enum scope)
3875 */
3876 if (s != 0
3877 && s->scope_node_type () == AST_Decl::NT_enum)
3878 {
3879 c = dynamic_cast<AST_Enum*> (s);
3881 if (c != 0)
3882 {
3883 e = idl_global->gen ()->create_enum_val (
3884 c->next_enum_val (),
3885 &n
3886 );
3887 e->enum_parent (c);
3888 e->annotation_appls (*annotations);
3889 }
3891 (void) s->fe_add_enum_val (e);
3892 }
3894 delete annotations;
3895 }
3896 ;
3898 map_type_spec
3899 : map_head
3900 '>'
3901 {
3902 AST_Map *map = 0;
3903 Decl_Annotations_Pair_Pair* type_pair = $1;
3904 Decl_Annotations_Pair *key_type = type_pair->first;
3905 Decl_Annotations_Pair *val_type = type_pair->second;
3907 /*
3908 * Remove map marker from scopes stack.
3909 */
3910 if (idl_global->scopes ().top () == 0)
3911 {
3912 idl_global->scopes ().pop ();
3913 }
3915 UTL_Scope *s = idl_global->scopes ().top_non_null ();
3917 /*
3918 * Create a node representing a map.
3919 */
3920 if (key_type && val_type)
3921 {
3922 AST_Type *ktp = dynamic_cast<AST_Type*> (key_type->decl);
3923 AST_Type *vtp = dynamic_cast<AST_Type*> (val_type->decl);
3925 if (ktp == 0 || vtp == 0)
3926 {
3927 ; // Error will be caught in FE_Declarator.
3928 }
3929 else
3930 {
3931 Identifier id ("map");
3932 UTL_ScopedName sn (&id, 0);
3933 ACE_CDR::ULong bound = 0UL;
3935 map =
3936 idl_global->gen ()->create_map (
3937 idl_global->gen ()->create_expr (
3938 bound,
3939 AST_Expression::EV_ulong
3940 ),
3941 ktp,
3942 vtp,
3943 &sn,
3944 s->is_local (),
3945 s->is_abstract ()
3946 );
3947 map->key_type_annotations (*key_type->annotations);
3948 map->value_type_annotations (*val_type->annotations);
3950 idl_global->err ()->anonymous_type_diagnostic ();
3951 }
3952 }
3954 delete key_type->annotations;
3955 delete val_type->annotations;
3956 delete type_pair;
3957 $$ = map;
3958 }
3959 ;
3961 map_head :
3962 IDL_MAP
3963 {
3964 idl_global->set_parse_state (IDL_GlobalData::PS_MapSeen);
3966 /*
3967 * Push a map marker on scopes stack.
3968 */
3969 idl_global->scopes ().push (0);
3970 }
3971 '<'
3972 annotations_maybe simple_type_spec
3973 {
3974 idl_global->set_parse_state(IDL_GlobalData::PS_MapKeyTypeSeen);
3975 }
3976 ','
3977 annotations_maybe simple_type_spec
3978 {
3979 idl_global->set_parse_state(IDL_GlobalData::PS_MapValueTypeSeen);
3980 Decl_Annotations_Pair *key = new Decl_Annotations_Pair;
3981 key->decl = $5;
3982 key->annotations = $4;
3984 Decl_Annotations_Pair *value = new Decl_Annotations_Pair;
3985 value->decl = $9;
3986 value->annotations = $8;
3988 Decl_Annotations_Pair_Pair* pairs = new Decl_Annotations_Pair_Pair;
3989 pairs->first = key;
3990 pairs->second = value;
3991 $$ = pairs;
3992 }
3993 ;
3995 sequence_type_spec
3996 : seq_head
3997 ','
3998 {
3999 idl_global->set_parse_state (IDL_GlobalData::PS_SequenceCommaSeen);
4000 }
4001 positive_int_expr
4002 {
4003 idl_global->set_parse_state (IDL_GlobalData::PS_SequenceExprSeen);
4004 }
4005 '>'
4006 {
4007 idl_global->set_parse_state (IDL_GlobalData::PS_SequenceQsSeen);
4009 AST_Sequence *seq = 0;
4010 Decl_Annotations_Pair *seq_head = $1;
4011 AST_Decl *type = 0;
4012 AST_Annotation_Appls *type_annotations = 0;
4013 if (seq_head)
4014 {
4015 type = seq_head->decl;
4016 type_annotations = seq_head->annotations;
4017 }
4018 delete seq_head;
4020 /*
4021 * Remove sequence marker from scopes stack.
4022 */
4023 if (idl_global->scopes ().top () == 0)
4024 {
4025 idl_global->scopes ().pop ();
4026 }
4028 UTL_Scope *s = idl_global->scopes ().top_non_null ();
4030 /*
4031 * Create a node representing a sequence
4032 */
4033 AST_Expression::AST_ExprValue *ev = 0;
4034 AST_Param_Holder *param_holder = 0;
4036 if ($4 != 0)
4037 {
4038 param_holder =
4039 $4->param_holder ();
4041 ev = $4->coerce (AST_Expression::EV_ulong);
4042 }
4044 // If the expression corresponds to a template parameter,
4045 // it's ok for the coercion to fail at this point. We check
4046 // for a type mismatch below.
4047 if (0 == $4
4048 || (0 == ev && 0 == param_holder))
4049 {
4050 idl_global->err ()->coercion_error ($4,
4051 AST_Expression::EV_ulong);
4052 }
4053 else if (type)
4054 {
4055 AST_Type *tp = dynamic_cast<AST_Type*> (type);
4057 if (0 == tp)
4058 {
4059 ; // Error will be caught in FE_Declarator.
4060 }
4061 else
4062 {
4063 Identifier id ("sequence");
4064 UTL_ScopedName sn (&id,
4065 0);
4067 seq =
4068 idl_global->gen ()->create_sequence (
4069 $4,
4070 tp,
4071 &sn,
4072 s->is_local (),
4073 s->is_abstract ()
4074 );
4075 seq->base_type_annotations (*type_annotations);
4077 idl_global->err ()->anonymous_type_diagnostic ();
4078 }
4079 }
4081 delete type_annotations;
4082 delete ev;
4083 ev = 0;
4084 $$ = seq;
4085 }
4086 | seq_head
4087 '>'
4088 {
4089 idl_global->set_parse_state (IDL_GlobalData::PS_SequenceQsSeen);
4091 AST_Sequence *seq = 0;
4092 Decl_Annotations_Pair *seq_head = $1;
4093 AST_Decl *type = 0;
4094 AST_Annotation_Appls *type_annotations = 0;
4095 if (seq_head)
4096 {
4097 type = seq_head->decl;
4098 type_annotations = seq_head->annotations;
4099 }
4100 delete seq_head;
4102 /*
4103 * Remove sequence marker from scopes stack.
4104 */
4105 if (idl_global->scopes ().top () == 0)
4106 {
4107 idl_global->scopes ().pop ();
4108 }
4110 UTL_Scope *s = idl_global->scopes ().top_non_null ();
4112 /*
4113 * Create a node representing a sequence.
4114 */
4115 if (type)
4116 {
4117 AST_Type *tp = dynamic_cast<AST_Type*> (type);
4119 if (tp == 0)
4120 {
4121 ; // Error will be caught in FE_Declarator.
4122 }
4123 else
4124 {
4125 Identifier id ("sequence");
4126 UTL_ScopedName sn (&id, 0);
4127 ACE_CDR::ULong bound = 0UL;
4129 seq =
4130 idl_global->gen ()->create_sequence (
4131 idl_global->gen ()->create_expr (
4132 bound,
4133 AST_Expression::EV_ulong
4134 ),
4135 tp,
4136 &sn,
4137 s->is_local (),
4138 s->is_abstract ()
4139 );
4140 seq->base_type_annotations (*type_annotations);
4142 idl_global->err ()->anonymous_type_diagnostic ();
4143 }
4144 }
4146 delete type_annotations;
4147 $$ = seq;
4148 }
4149 ;
4151 seq_head :
4152 IDL_SEQUENCE
4153 {
4154 idl_global->set_parse_state (IDL_GlobalData::PS_SequenceSeen);
4156 /*
4157 * Push a sequence marker on scopes stack.
4158 */
4159 idl_global->scopes ().push (0);
4160 }
4161 '<'
4162 {
4163 idl_global->set_parse_state (IDL_GlobalData::PS_SequenceSqSeen);
4164 }
4165 annotations_maybe simple_type_spec
4166 {
4167 idl_global->set_parse_state (IDL_GlobalData::PS_SequenceTypeSeen);
4168 Decl_Annotations_Pair *seq_head = new Decl_Annotations_Pair;
4169 seq_head->decl = $6;
4170 seq_head->annotations = $5;
4171 $$ = seq_head;
4172 }
4173 ;
4175 fixed_type_spec
4176 : IDL_FIXED '<' positive_int_expr ',' const_expr '>'
4177 {
4178 $5->evaluate (AST_Expression::EK_positive_int);
4179 $$ = idl_global->gen ()->create_fixed ($3, $5);
4180 }
4181 ;
4183 string_type_spec
4184 : string_head
4185 '<'
4186 {
4187 idl_global->set_parse_state (IDL_GlobalData::PS_StringSqSeen);
4188 }
4189 positive_int_expr
4190 {
4191 idl_global->set_parse_state (IDL_GlobalData::PS_StringExprSeen);
4192 }
4193 '>'
4194 {
4195 idl_global->set_parse_state (IDL_GlobalData::PS_StringQsSeen);
4197 /*
4198 * Create a node representing a string.
4199 */
4200 AST_Expression::AST_ExprValue *ev = 0;
4202 if ($4 != 0)
4203 {
4204 ev = $4->coerce (AST_Expression::EV_ulong);
4205 }
4207 if (0 == $4 || 0 == ev)
4208 {
4209 idl_global->err ()->coercion_error ($4,
4210 AST_Expression::EV_ulong);
4211 $$ = 0;
4212 }
4213 else
4214 {
4215 tao_string_decl = idl_global->gen ()->create_string ($4);
4217 /*
4218 * Add this AST_String to the types defined in the global scope.
4219 */
4220 idl_global->root ()->fe_add_string (
4221 dynamic_cast<AST_String*> (
4222 tao_string_decl));
4224 idl_global->err ()->anonymous_type_diagnostic ();
4226 $$ = tao_string_decl;
4227 }
4229 delete ev;
4230 ev = 0;
4231 }
4232 | string_head
4233 {
4234 idl_global->set_parse_state (IDL_GlobalData::PS_StringCompleted);
4236 /*
4237 * Create a node representing a string.
4238 */
4239 ACE_CDR::ULong bound = 0UL;
4240 tao_string_decl =
4241 idl_global->gen ()->create_string (
4242 idl_global->gen ()->create_expr (bound,
4243 AST_Expression::EV_ulong)
4244 );
4246 /*
4247 * Add this AST_String to the types defined in the global scope.
4248 */
4249 idl_global->root ()->fe_add_string (
4250 dynamic_cast<AST_String*> (
4251 tao_string_decl));
4253 $$ = tao_string_decl;
4254 }
4255 ;
4257 string_head :
4258 IDL_STRING
4259 {
4260 idl_global->set_parse_state (IDL_GlobalData::PS_StringSeen);
4261 }
4262 ;
4264 wstring_type_spec
4265 : wstring_head
4266 '<'
4267 {
4268 idl_global->set_parse_state (IDL_GlobalData::PS_StringSqSeen);
4269 }
4270 positive_int_expr
4271 {
4272 idl_global->set_parse_state (IDL_GlobalData::PS_StringExprSeen);
4273 }
4274 '>'
4275 {
4276 idl_global->set_parse_state (IDL_GlobalData::PS_StringQsSeen);
4278 /*
4279 * Create a node representing a string.
4280 */
4281 AST_Expression::AST_ExprValue *ev = 0;
4283 if ($4 != 0)
4284 {
4285 ev = $4->coerce (AST_Expression::EV_ulong);
4286 }
4288 if (0 == $4 || 0 == ev)
4289 {
4290 idl_global->err ()->coercion_error ($4,
4291 AST_Expression::EV_ulong);
4292 $$ = 0;
4293 }
4294 else
4295 {
4296 AST_String *string = idl_global->gen ()->create_wstring ($4);
4298 /*
4299 * Add this AST_String to the types defined in the global scope.
4300 */
4301 idl_global->root ()->fe_add_string (
4302 dynamic_cast<AST_String*> (
4303 string));
4305 idl_global->err ()->anonymous_type_diagnostic ();
4307 $$ = string;
4308 }
4310 delete ev;
4311 ev = 0;
4312 }
4313 | wstring_head
4314 {
4315 idl_global->set_parse_state (IDL_GlobalData::PS_StringCompleted);
4317 /*
4318 * Create a node representing a wstring.
4319 */
4320 ACE_CDR::ULong bound = 0UL;
4321 AST_String *string =
4322 idl_global->gen ()->create_wstring (
4323 idl_global->gen ()->create_expr (bound,
4324 AST_Expression::EV_ulong)
4325 );
4327 /*
4328 * Add this AST_String to the types defined in the global scope.
4329 */
4330 idl_global->root ()->fe_add_string (
4331 dynamic_cast<AST_String*> (
4332 string));
4334 $$ = string;
4335 }
4336 ;
4338 wstring_head :
4339 IDL_WSTRING
4340 {
4341 idl_global->set_parse_state (IDL_GlobalData::PS_StringSeen);
4342 }
4343 ;
4345 array_declarator :
4346 defining_id
4347 {
4348 idl_global->set_parse_state (IDL_GlobalData::PS_ArrayIDSeen);
4349 }
4350 annotations_maybe at_least_one_array_dim
4351 {
4352 idl_global->set_parse_state (IDL_GlobalData::PS_ArrayCompleted);
4354 AST_Array *array = 0;
4355 AST_Annotation_Appls *base_type_annotations = $3;
4356 UTL_ExprList *array_dims = $4;
4358 /*
4359 * Create a node representing an array.
4360 */
4361 if (array_dims)
4362 {
4363 UTL_ScopedName sn ($1,
4364 0);
4365 array =
4366 idl_global->gen ()->create_array (
4367 &sn,
4368 array_dims->length (),
4369 array_dims,
4370 0,
4371 0
4372 );
4373 array->base_type_annotations (*base_type_annotations);
4374 sn.destroy ();
4376 idl_global->err ()->anonymous_type_diagnostic ();
4377 }
4379 array_dims->destroy ();
4380 delete array_dims;
4382 delete base_type_annotations;
4384 $$ = array;
4385 }
4386 ;
4388 at_least_one_array_dim :
4389 array_dim array_dims
4390 {
4391 ACE_NEW_RETURN ($$,
4392 UTL_ExprList ($1,
4393 $2),
4394 1);
4395 }
4396 ;
4398 array_dims
4399 : array_dims array_dim
4400 {
4401 UTL_ExprList *el = 0;
4402 ACE_NEW_RETURN (el,
4403 UTL_ExprList ($2,
4404 0),
4405 1);
4407 if ($1 == 0)
4408 {
4409 $$ = el;
4410 }
4411 else
4412 {
4413 $1->nconc (el);
4414 $$ = $1;
4415 }
4416 }
4417 | %empty
4418 {
4419 $$ = 0;
4420 }
4421 ;
4423 array_dim :
4424 '['
4425 {
4426 idl_global->set_parse_state (IDL_GlobalData::PS_DimSqSeen);
4427 }
4428 positive_int_expr
4429 {
4430 idl_global->set_parse_state (IDL_GlobalData::PS_DimExprSeen);
4431 }
4432 ']'
4433 {
4434 idl_global->set_parse_state (IDL_GlobalData::PS_DimQsSeen);
4436 /*
4437 * Array dimensions are expressions which must be coerced to
4438 * positive integers.
4439 */
4440 AST_Expression::AST_ExprValue *ev = 0;
4441 AST_Param_Holder *param_holder = 0;
4443 if ($3 != 0)
4444 {
4445 param_holder =
4446 $3->param_holder ();
4448 ev =
4449 $3->coerce (AST_Expression::EV_ulong);
4450 }
4452 if (0 == $3
4453 || (ev == 0 && param_holder == 0))
4454 {
4455 idl_global->err ()->coercion_error ($3,
4456 AST_Expression::EV_ulong);
4457 $$ = 0;
4458 }
4459 else
4460 {
4461 if (param_holder != 0)
4462 {
4463 AST_Expression::ExprType et =
4464 param_holder->info ()->const_type_;
4466 // If the bound expression represents a
4467 // template parameter, it must be a const
4468 // and of type unsigned long.
4469 if (et != AST_Expression::EV_ulong)
4470 {
4471 idl_global->err ()->mismatched_template_param (
4472 param_holder->info ()->name_.c_str ());
4474 delete ev;
4475 ev = 0;
4476 return 1;
4477 }
4478 }
4480 $$ = $3;
4481 }
4483 delete ev;
4484 ev = 0;
4485 }
4486 ;
4488 attribute
4489 : attribute_readonly
4490 | attribute_readwrite
4491 ;
4493 attribute_readonly :
4494 IDL_READONLY
4495 {
4496 idl_global->set_parse_state (IDL_GlobalData::PS_AttrROSeen);
4497 }
4498 IDL_ATTRIBUTE
4499 {
4500 idl_global->set_parse_state (IDL_GlobalData::PS_AttrSeen);
4501 }
4502 param_type_spec
4503 {
4504 idl_global->set_parse_state (IDL_GlobalData::PS_AttrTypeSeen);
4505 }
4506 at_least_one_simple_declarator
4507 {
4508 idl_global->set_parse_state (IDL_GlobalData::PS_AttrDeclsSeen);
4509 }
4510 opt_raises
4511 {
4512 UTL_Scope *s = idl_global->scopes ().top_non_null ();
4513 AST_Attribute *a = 0;
4514 FE_Declarator *d = 0;
4516 idl_global->set_parse_state (IDL_GlobalData::PS_OpRaiseCompleted);
4518 /*
4519 * Create nodes representing attributes and add them to the
4520 * enclosing scope.
4521 */
4522 if (s != 0 && $5 != 0 && $7 != 0)
4523 {
4524 for (UTL_DecllistActiveIterator l ($7); !l.is_done (); l.next ())
4525 {
4526 d = l.item ();
4528 if (d == 0)
4529 {
4530 continue;
4531 }
4533 AST_Type *tp = d->compose ($5);
4535 if (tp == 0)
4536 {
4537 continue;
4538 }
4540 a = idl_global->gen ()->create_attribute (
4541 true, tp, d->name (), s->is_local (), s->is_abstract ());
4543 if ($9 != 0)
4544 {
4545 (void) a->fe_add_get_exceptions ($9);
4547 $9->destroy ();
4548 delete $9;
4549 $9 = 0;
4550 }
4552 (void) s->fe_add_attribute (a);
4553 }
4554 }
4556 $7->destroy ();
4557 delete $7;
4558 $7 = 0;
4560 $$ = a;
4561 }
4562 ;
4564 attribute_readwrite :
4565 IDL_ATTRIBUTE
4566 {
4567 idl_global->set_parse_state (IDL_GlobalData::PS_AttrSeen);
4568 }
4569 param_type_spec
4570 {
4571 idl_global->set_parse_state (IDL_GlobalData::PS_AttrTypeSeen);
4572 }
4573 at_least_one_simple_declarator
4574 {
4575 idl_global->set_parse_state (IDL_GlobalData::PS_AttrDeclsSeen);
4576 }
4577 opt_getraises
4578 {
4579 idl_global->set_parse_state (IDL_GlobalData::PS_OpGetRaiseCompleted);
4580 }
4581 opt_setraises
4582 {
4583 UTL_Scope *s = idl_global->scopes ().top_non_null ();
4584 AST_Attribute *a = 0;
4585 FE_Declarator *d = 0;
4587 idl_global->set_parse_state (IDL_GlobalData::PS_OpSetRaiseCompleted);
4589 /*
4590 * Create nodes representing attributes and add them to the
4591 * enclosing scope.
4592 */
4593 if (s != 0 && $3 != 0 && $5 != 0)
4594 {
4595 for (UTL_DecllistActiveIterator l ($5); !l.is_done (); l.next ())
4596 {
4597 d = l.item ();
4599 if (d == 0)
4600 {
4601 continue;
4602 }
4604 AST_Type *tp = d->compose ($3);
4606 if (tp == 0)
4607 {
4608 continue;
4609 }
4611 a = idl_global->gen ()->create_attribute (
4612 false, tp, d->name (), s->is_local (), s->is_abstract ());
4614 if ($7 != 0)
4615 {
4616 (void) a->fe_add_get_exceptions ($7);
4618 $7->destroy ();
4619 delete $7;
4620 $7 = 0;
4621 }
4623 if ($9 != 0)
4624 {
4625 (void) a->fe_add_set_exceptions ($9);
4627 $9->destroy ();
4628 delete $9;
4629 $9 = 0;
4630 }
4632 (void) s->fe_add_attribute (a);
4633 }
4634 }
4636 $5->destroy ();
4637 delete $5;
4638 $5 = 0;
4640 $$ = a;
4641 }
4642 ;
4644 exception :
4645 IDL_EXCEPTION
4646 {
4647 idl_global->set_parse_state (IDL_GlobalData::PS_ExceptSeen);
4648 }
4649 defining_id
4650 {
4651 Identifier *&id = $3;
4652 UTL_Scope *scope = idl_global->scopes ().top_non_null ();
4653 UTL_ScopedName scoped_name (id, 0);
4654 AST_Exception *exception = 0;
4655 idl_global->set_parse_state (IDL_GlobalData::PS_ExceptIDSeen);
4657 /*
4658 * Create a node representing an exception and add it to
4659 * the enclosing scope.
4660 */
4661 if (scope)
4662 {
4663 exception = idl_global->gen ()->create_exception (
4664 &scoped_name,
4665 scope->is_local (),
4666 scope->is_abstract ());
4667 scope->fe_add_exception (exception);
4668 }
4670 /*
4671 * Push the exception scope on the scope stack.
4672 */
4673 idl_global->scopes ().push (exception);
4675 id->destroy ();
4676 delete id;
4677 id = 0;
4679 $<dcval>$ = exception;
4680 }
4681 '{'
4682 {
4683 idl_global->set_parse_state (IDL_GlobalData::PS_ExceptSqSeen);
4684 }
4685 members
4686 {
4687 idl_global->set_parse_state (IDL_GlobalData::PS_ExceptBodySeen);
4688 }
4689 '}'
4690 {
4691 idl_global->set_parse_state (IDL_GlobalData::PS_ExceptQsSeen);
4692 /*
4693 * Done with this exception. Pop its scope from the scope stack.
4694 */
4695 idl_global->scopes ().pop ();
4697 $$ = $<dcval>4;
4698 }
4699 ;
4701 operation
4702 : opt_op_attribute op_type_spec
4703 {
4704 idl_global->set_parse_state (IDL_GlobalData::PS_OpTypeSeen);
4705 }
4706 IDENTIFIER
4707 {
4708 AST_Operation *op = 0;
4709 UTL_Scope *scope = idl_global->scopes ().top_non_null ();
4711 AST_Operation::Flags op_flags = $1;
4712 AST_Decl *type_node = $2;
4713 $2 = 0;
4714 Identifier id ($4);
4715 ACE::strdelete ($4);
4716 $4 = 0;
4718 UTL_ScopedName name (&id, 0);
4719 idl_global->set_parse_state (IDL_GlobalData::PS_OpIDSeen);
4721 /*
4722 * Create a node representing an operation on an interface
4723 * and add it to its enclosing scope.
4724 */
4725 if (scope != 0 && type_node != 0)
4726 {
4727 AST_Type *type = dynamic_cast<AST_Type*> (type_node);
4729 if (type == 0)
4730 {
4731 idl_global->err ()->not_a_type (type_node);
4732 }
4733 else if (type->node_type () == AST_Decl::NT_except)
4734 {
4735 idl_global->err ()->not_a_type (type_node);
4736 }
4737 else
4738 {
4739 AST_Decl *d = ScopeAsDecl (scope);
4740 AST_Decl::NodeType nt = d->node_type ();
4741 const bool local = scope->is_local ()
4742 || nt == AST_Decl::NT_valuetype
4743 || nt == AST_Decl::NT_eventtype;
4745 op = idl_global->gen ()->create_operation (
4746 type, op_flags, &name, local, scope->is_abstract ());
4748 if (!local && type->is_local ())
4749 {
4750 idl_global->err ()->local_remote_mismatch (type, op);
4751 op->destroy ();
4752 delete op;
4753 op = 0;
4754 }
4755 else
4756 {
4757 scope->fe_add_operation (op);
4758 }
4759 }
4760 }
4762 /*
4763 * Push the operation scope onto the scopes stack.
4764 */
4765 idl_global->scopes ().push (op);
4766 }
4767 parameter_list
4768 {
4769 idl_global->set_parse_state (IDL_GlobalData::PS_OpParsCompleted);
4770 }
4771 opt_raises
4772 {
4773 idl_global->set_parse_state (IDL_GlobalData::PS_OpRaiseCompleted);
4774 }
4775 opt_context
4776 {
4777 UTL_Scope *s = idl_global->scopes ().top_non_null ();
4778 AST_Operation *o = 0;
4779 idl_global->set_parse_state (IDL_GlobalData::PS_OpCompleted);
4781 /*
4782 * Add exceptions and context to the operation.
4783 */
4784 if (s != 0 && s->scope_node_type () == AST_Decl::NT_op)
4785 {
4786 o = dynamic_cast<AST_Operation*> (s);
4788 if ($8 != 0 && o != 0)
4789 {
4790 (void) o->fe_add_exceptions ($8);
4791 }
4793 if ($10 != 0)
4794 {
4795 (void) o->fe_add_context ($10);
4796 }
4797 }
4799 /*
4800 * Done with this operation. Pop its scope from the scopes stack.
4801 */
4802 idl_global->scopes ().pop ();
4804 $$ = o;
4805 }
4806 ;
4808 opt_op_attribute
4809 : IDL_ONEWAY
4810 {
4811 idl_global->set_parse_state (IDL_GlobalData::PS_OpAttrSeen);
4812 $$ = AST_Operation::OP_oneway;
4813 }
4814 | IDL_IDEMPOTENT
4815 {
4816 idl_global->set_parse_state (IDL_GlobalData::PS_OpAttrSeen);
4817 $$ = AST_Operation::OP_idempotent;
4818 }
4819 | %empty
4820 {
4821 $$ = AST_Operation::OP_noflags;
4822 }
4823 ;
4825 op_type_spec
4826 : param_type_spec
4827 | IDL_VOID
4828 {
4829 $$ =
4830 idl_global->scopes ().bottom ()->lookup_primitive_type (
4831 AST_Expression::EV_void
4832 );
4833 }
4834 ;
4836 init_decl
4837 : IDL_FACTORY
4838 {
4839 //@@ PS_FactorySeen?
4840 idl_global->set_parse_state (IDL_GlobalData::PS_OpTypeSeen);
4841 }
4842 IDENTIFIER
4843 {
4844 UTL_Scope *s = idl_global->scopes ().top_non_null ();
4846 if (s->is_abstract ())
4847 {
4848 //@@ Fire error
4849 ACE_ERROR ((LM_ERROR,
4850 ACE_TEXT ("error in %C line %d:\n")
4851 ACE_TEXT ("Abstract valuetype can't have a ")
4852 ACE_TEXT ("factory construct.\n"),
4853 idl_global->filename ()->get_string (),
4854 idl_global->lineno ()));
4856 idl_global->set_err_count (idl_global->err_count () + 1);
4857 }
4859 Identifier id ($3);
4860 ACE::strdelete ($3);
4861 $3 = 0;
4863 UTL_ScopedName n (&id,
4864 0);
4865 AST_Factory *factory = 0;
4866 idl_global->set_parse_state (IDL_GlobalData::PS_OpIDSeen);
4868 /*
4869 * Create a node representing an factory construct
4870 * and add it to its enclosing scope
4871 */
4872 if (s != 0)
4873 {
4874 factory = idl_global->gen ()->create_factory (&n);
4875 (void) s->fe_add_factory (factory);
4876 }
4878 /*
4879 * Push the operation scope onto the scopes stack.
4880 */
4881 idl_global->scopes ().push (factory);
4883 $<dcval>$ = factory;
4884 }
4885 init_parameter_list
4886 {
4887 idl_global->set_parse_state (IDL_GlobalData::PS_OpParsCompleted);
4888 }
4889 opt_raises
4890 {
4891 idl_global->set_parse_state (IDL_GlobalData::PS_OpRaiseCompleted);
4893 if ($7)
4894 {
4895 UTL_Scope *s = idl_global->scopes ().top_non_null ();
4896 AST_Factory *f = dynamic_cast<AST_Factory*> (s);
4897 (void) f->fe_add_exceptions ($7);
4898 }
4900 idl_global->scopes ().pop ();
4902 $$ = $<dcval>4;
4903 }
4904 ;
4906 init_parameter_list
4907 : '('
4908 {
4909 idl_global->set_parse_state (IDL_GlobalData::PS_OpSqSeen);
4910 }
4911 ')'
4912 {
4913 idl_global->set_parse_state (IDL_GlobalData::PS_OpQsSeen);
4914 }
4915 | '('
4916 {
4917 idl_global->set_parse_state (IDL_GlobalData::PS_OpSqSeen);
4918 }
4919 at_least_one_in_parameter
4920 ')'
4921 {
4922 idl_global->set_parse_state (IDL_GlobalData::PS_OpQsSeen);
4923 }
4924 ;
4926 at_least_one_in_parameter : in_parameter in_parameters ;
4928 in_parameters
4929 : in_parameters
4930 ','
4931 {
4932 idl_global->set_parse_state (IDL_GlobalData::PS_OpParCommaSeen);
4933 }
4934 in_parameter
4935 | %empty
4936 ;
4938 in_parameter :
4939 IDL_IN
4940 {
4941 idl_global->set_parse_state (IDL_GlobalData::PS_OpParDirSeen);
4942 }
4943 param_type_spec
4944 {
4945 idl_global->set_parse_state (IDL_GlobalData::PS_OpParTypeSeen);
4946 }
4947 declarator
4948 {
4949 UTL_Scope *s = idl_global->scopes ().top_non_null ();
4950 AST_Argument *a = 0;
4951 idl_global->set_parse_state (IDL_GlobalData::PS_OpParDeclSeen);
4953 /*
4954 * Create a node representing an argument to an operation
4955 * Add it to the enclosing scope (the operation scope).
4956 */
4957 if ($3 != 0
4958 && $5 != 0 &&
4959 s != 0)
4960 {
4961 AST_Type *tp = $5->compose ($3);
4963 if (tp != 0)
4964 {
4965 a = idl_global->gen ()->create_argument (
4966 AST_Argument::dir_IN,
4967 tp,
4968 $5->name ()
4969 );
4971 (void) s->fe_add_argument (a);
4972 }
4973 }
4975 $5->destroy ();
4976 delete $5;
4977 $5 = 0;
4978 }
4979 ;
4981 parameter_list
4982 : '('
4983 {
4984 idl_global->set_parse_state (IDL_GlobalData::PS_OpSqSeen);
4985 }
4986 ')'
4987 {
4988 idl_global->set_parse_state (IDL_GlobalData::PS_OpQsSeen);
4989 }
4990 | '('
4991 {
4992 idl_global->set_parse_state (IDL_GlobalData::PS_OpSqSeen);
4993 }
4994 at_least_one_parameter
4995 ')'
4996 {
4997 idl_global->set_parse_state (IDL_GlobalData::PS_OpQsSeen);
4998 }
4999 ;
5001 at_least_one_parameter : parameter parameters ;
5003 parameters
5004 : parameters
5005 ','
5006 {
5007 idl_global->set_parse_state (IDL_GlobalData::PS_OpParCommaSeen);
5008 }
5009 parameter
5010 | %empty
5011 ;
5013 parameter :
5014 direction
5015 {
5016 idl_global->set_parse_state (IDL_GlobalData::PS_OpParDirSeen);
5017 }
5018 param_type_spec
5019 {
5020 idl_global->set_parse_state (IDL_GlobalData::PS_OpParTypeSeen);
5021 }
5022 declarator
5023 {
5024 UTL_Scope *s = idl_global->scopes ().top_non_null ();
5025 AST_Argument *a = 0;
5026 idl_global->set_parse_state (IDL_GlobalData::PS_OpParDeclSeen);
5028 /*
5029 * Create a node representing an argument to an operation
5030 * Add it to the enclosing scope (the operation scope).
5031 */
5032 if ($3 != 0
5033 && $5 != 0
5034 && s != 0)
5035 {
5036 AST_Type *tp = $5->compose ($3);
5038 if (tp != 0)
5039 {
5040 if (!s->is_local () && tp->is_local ())
5041 {
5042 idl_global->err ()->local_remote_mismatch (tp, s);
5043 }
5044 else
5045 {
5046 a =
5047 idl_global->gen ()->create_argument (
5048 $1,
5049 tp,
5050 $5->name ()
5051 );
5052 (void) s->fe_add_argument (a);
5053 }
5054 }
5055 }
5057 $5->destroy ();
5058 delete $5;
5059 $5 = 0;
5060 }
5061 ;
5063 param_type_spec
5064 : base_type_spec
5065 {
5066 $$ =
5067 idl_global->scopes ().bottom ()->lookup_primitive_type (
5068 $1
5069 );
5070 }
5071 | string_type_spec
5072 | wstring_type_spec
5073 | scoped_name
5074 {
5075 UTL_Scope *s = idl_global->scopes ().top_non_null ();
5076 AST_Decl *d = 0;
5077 UTL_ScopedName *n = $1;
5079 if (s != 0)
5080 {
5081 d = s->lookup_by_name (n, false, false);
5082 }
5084 if (d == 0)
5085 {
5086 idl_global->err ()->lookup_error (n);
5087 $1->destroy ();
5088 $1 = 0;
5090 /* If we don't return here, we'll crash later.*/
5091 return 1;
5092 }
5093 else
5094 {
5095 d->last_referenced_as ($1);
5096 AST_Decl::NodeType nt = d->node_type ();
5097 AST_Type *t = dynamic_cast<AST_Type*> (d);
5098 AST_Typedef *td = 0;
5099 bool can_be_undefined = false;
5101 if (nt == AST_Decl::NT_typedef)
5102 {
5103 // This code block ensures that a sequence of
5104 // as-yet-undefined struct or union isn't used
5105 // as a return type or argument.
5106 td = dynamic_cast<AST_Typedef*> (d);
5107 AST_Type *pbt = td->primitive_base_type ();
5109 if (pbt->node_type () == AST_Decl::NT_sequence)
5110 {
5111 t = pbt;
5112 AST_Sequence *seq_type =
5113 dynamic_cast<AST_Sequence*> (pbt);
5114 AST_Type *elem_type =
5115 seq_type->base_type ();
5116 AST_Decl::NodeType elem_nt =
5117 elem_type->node_type ();
5119 if (elem_nt == AST_Decl::NT_typedef)
5120 {
5121 AST_Typedef *elem_td =
5122 dynamic_cast<AST_Typedef*> (elem_type);
5123 elem_type = elem_td->primitive_base_type ();
5124 elem_nt = elem_type->node_type ();
5125 }
5127 if (elem_nt == AST_Decl::NT_interface
5128 || elem_nt == AST_Decl::NT_interface_fwd
5129 || elem_nt == AST_Decl::NT_valuetype
5130 || elem_nt == AST_Decl::NT_valuetype_fwd
5131 || elem_nt == AST_Decl::NT_component
5132 || elem_nt == AST_Decl::NT_component_fwd)
5133 {
5134 can_be_undefined = true;
5135 }
5136 }
5138 if (pbt->node_type() == AST_Decl::NT_map)
5139 {
5140 t = pbt;
5141 AST_Map *map_type =
5142 dynamic_cast<AST_Map*> (pbt);
5143 AST_Type *key_type =
5144 map_type->key_type ();
5145 AST_Type *val_type =
5146 map_type->value_type ();
5148 AST_Decl::NodeType key_nt =
5149 key_type->node_type ();
5150 AST_Decl::NodeType val_nt =
5151 val_type->node_type ();
5153 if (key_nt == AST_Decl::NT_typedef)
5154 {
5155 AST_Typedef *key_td =
5156 dynamic_cast<AST_Typedef*> (key_type);
5157 key_type = key_td->primitive_base_type ();
5158 key_nt = key_type->node_type ();
5159 }
5161 if (val_nt == AST_Decl::NT_typedef)
5162 {
5163 AST_Typedef *val_td =
5164 dynamic_cast<AST_Typedef*> (val_type);
5165 val_type = val_td->primitive_base_type ();
5166 val_nt = val_type->node_type ();
5167 }
5169 if (key_nt == AST_Decl::NT_interface
5170 || key_nt == AST_Decl::NT_interface_fwd
5171 || key_nt == AST_Decl::NT_valuetype
5172 || key_nt == AST_Decl::NT_valuetype_fwd
5173 || key_nt == AST_Decl::NT_component
5174 || key_nt == AST_Decl::NT_component_fwd
5175 || val_nt == AST_Decl::NT_interface
5176 || val_nt == AST_Decl::NT_interface_fwd
5177 || val_nt == AST_Decl::NT_valuetype
5178 || val_nt == AST_Decl::NT_valuetype_fwd
5179 || val_nt == AST_Decl::NT_component
5180 || val_nt == AST_Decl::NT_component_fwd)
5181 {
5182 can_be_undefined = true;
5183 }
5184 }
5186 if (! t->is_defined () && ! can_be_undefined)
5187 {
5188 idl_global->err ()->error1 (
5189 UTL_Error::EIDL_ILLEGAL_ADD,
5190 (nt == AST_Decl::NT_typedef ? td : t));
5192 /* If we don't return here, we'll crash later.*/
5193 return 1;
5194 }
5195 }
5196 else
5197 {
5198 // For forward declared structs and unions, we
5199 // want the full definition, but we need to
5200 // check that it's been fully defined.
5201 AST_StructureFwd *fwd =
5202 dynamic_cast<AST_StructureFwd*> (d);
5204 if (fwd != 0)
5205 {
5206 t = fwd->full_definition ();
5208 if (! t->is_defined ())
5209 {
5210 idl_global->err ()->error1 (
5211 UTL_Error::EIDL_ILLEGAL_ADD,
5212 t);
5214 /* If we don't return here, we'll crash later.*/
5215 return 1;
5216 }
5218 d = t;
5219 }
5220 }
5221 }
5223 $$ = d;
5224 }
5225 ;
5227 direction
5228 : IDL_IN
5229 {
5230 $$ = AST_Argument::dir_IN;
5231 }
5232 | IDL_OUT
5233 {
5234 $$ = AST_Argument::dir_OUT;
5235 }
5236 | IDL_INOUT
5237 {
5238 $$ = AST_Argument::dir_INOUT;
5239 }
5240 ;
5242 opt_raises
5243 : IDL_RAISES
5244 {
5245 idl_global->set_parse_state (IDL_GlobalData::PS_OpRaiseSeen);
5246 }
5247 '('
5248 {
5249 idl_global->set_parse_state (IDL_GlobalData::PS_OpRaiseSqSeen);
5250 }
5251 at_least_one_scoped_name
5252 ')'
5253 {
5254 idl_global->set_parse_state (IDL_GlobalData::PS_OpRaiseQsSeen);
5255 $$ = $5;
5256 }
5257 | %empty
5258 {
5259 $$ = 0;
5260 }
5261 ;
5263 opt_getraises
5264 : IDL_GETRAISES
5265 {
5266 idl_global->set_parse_state (IDL_GlobalData::PS_OpGetRaiseSeen);
5267 }
5268 '('
5269 {
5270 idl_global->set_parse_state (IDL_GlobalData::PS_OpGetRaiseSqSeen);
5271 }
5272 at_least_one_scoped_name
5273 ')'
5274 {
5275 idl_global->set_parse_state (IDL_GlobalData::PS_OpGetRaiseQsSeen);
5276 $$ = $5;
5277 }
5278 | %empty
5279 {
5280 $$ = 0;
5281 }
5282 ;
5284 opt_setraises
5285 : IDL_SETRAISES
5286 {
5287 idl_global->set_parse_state (IDL_GlobalData::PS_OpSetRaiseSeen);
5288 }
5289 '('
5290 {
5291 idl_global->set_parse_state (IDL_GlobalData::PS_OpSetRaiseSqSeen);
5292 }
5293 at_least_one_scoped_name
5294 ')'
5295 {
5296 idl_global->set_parse_state (IDL_GlobalData::PS_OpSetRaiseQsSeen);
5297 $$ = $5;
5298 }
5299 | %empty
5300 {
5301 $$ = 0;
5302 }
5303 ;
5305 opt_context
5306 : IDL_CONTEXT
5307 {
5308 idl_global->set_parse_state (IDL_GlobalData::PS_OpContextSeen);
5309 }
5310 '('
5311 {
5312 idl_global->set_parse_state (IDL_GlobalData::PS_OpContextSqSeen);
5313 }
5314 at_least_one_string_literal
5315 ')'
5316 {
5317 idl_global->set_parse_state (IDL_GlobalData::PS_OpContextQsSeen);
5318 $$ = $5;
5319 }
5320 | %empty
5321 {
5322 $$ = 0;
5323 }
5324 ;
5326 at_least_one_string_literal :
5327 IDL_STRING_LITERAL string_literals
5328 {
5329 ACE_NEW_RETURN ($<slval>$,
5330 UTL_StrList ($1,
5331 $2),
5332 1);
5333 }
5334 ;
5336 string_literals
5337 : string_literals
5338 ','
5339 {
5340 idl_global->set_parse_state (IDL_GlobalData::PS_OpContextCommaSeen);
5341 }
5342 IDL_STRING_LITERAL
5343 {
5344 UTL_StrList *sl = 0;
5345 ACE_NEW_RETURN (sl,
5346 UTL_StrList ($4,
5347 0),
5348 1);
5350 if ($1 == 0)
5351 {
5352 $<slval>$ = sl;
5353 }
5354 else
5355 {
5356 $1->nconc (sl);
5357 $<slval>$ = $1;
5358 }
5359 }
5360 | %empty
5361 {
5362 $$ = 0;
5363 }
5364 ;
5366 typeid_dcl
5367 : IDL_TYPEID scoped_name IDL_STRING_LITERAL
5368 {
5369 UTL_Scope *s = idl_global->scopes ().top_non_null ();
5370 AST_Decl *d =
5371 s->lookup_by_name ($2);
5373 if (d == 0)
5374 {
5375 idl_global->err ()->lookup_error ($2);
5376 }
5377 else
5378 {
5379 d->set_id_with_typeid (
5380 $3->get_string ()
5381 );
5382 }
5384 $2->destroy ();
5385 delete $2;
5386 $2 = 0;
5388 $3->destroy ();
5389 delete $3;
5390 $3 = 0;
5392 $$ = 0;
5393 }
5394 ;
5396 typeprefix_dcl
5397 : IDL_TYPEPREFIX scoped_name IDL_STRING_LITERAL
5398 {
5399 UTL_Scope *s = idl_global->scopes ().top_non_null ();
5400 AST_Decl *d = ScopeAsDecl (s);
5402 // If we are in a module, we want to avoid a lookup unless the
5403 // typeprefix is to be applied to some other scope, since we
5404 // might get a previous opening of the module, and the prefix
5405 // of this opening would never get checked or set.
5406 if (d->name ()->compare ($2) != 0)
5407 {
5408 d =
5409 s->lookup_by_name ($2);
5410 }
5412 if (d == 0)
5413 {
5414 idl_global->err ()->lookup_error ($2);
5415 }
5416 else
5417 {
5418 d->set_prefix_with_typeprefix (
5419 $3->get_string ()
5420 );
5421 }
5423 $2->destroy ();
5424 delete $2;
5425 $2 = 0;
5427 $3->destroy ();
5428 delete $3;
5429 $3 = 0;
5431 $$ = 0;
5432 }
5433 ;
5435 component
5436 : component_decl
5437 | component_forward_decl
5438 ;
5440 component_forward_decl :
5441 IDL_COMPONENT
5442 defining_id
5443 {
5444 UTL_Scope *s = idl_global->scopes ().top_non_null ();
5445 UTL_ScopedName n ($2,
5446 0);
5447 AST_ComponentFwd *f = 0;
5448 idl_global->set_parse_state (
5449 IDL_GlobalData::PS_ComponentForwardSeen
5450 );
5452 /*
5453 * Create a node representing a forward declaration of a
5454 * component. Store it in the enclosing scope.
5455 */
5456 if (s != 0)
5457 {
5458 f = idl_global->gen ()->create_component_fwd (&n);
5459 (void) s->fe_add_component_fwd (f);
5460 }
5462 $2->destroy ();
5463 delete $2;
5464 $2 = 0;
5466 $$ = 0;
5467 }
5468 ;
5470 component_decl :
5471 component_header
5472 {
5473 FE_ComponentHeader *&component_header = $1;
5474 UTL_Scope *scope = idl_global->scopes ().top_non_null ();
5475 AST_Component *component = 0;
5477 /*
5478 * Make a new component node and add it to the enclosing scope.
5479 */
5480 if (scope && component_header)
5481 {
5482 component = idl_global->gen ()->create_component (
5483 component_header->name (),
5484 component_header->base_component (),
5485 component_header->supports (),
5486 component_header->n_supports (),
5487 component_header->supports_flat (),
5488 component_header->n_supports_flat ());
5489 AST_Interface *component_as_interface =
5490 dynamic_cast<AST_Interface *> (component);
5491 AST_Interface::fwd_redefinition_helper (
5492 component_as_interface, scope);
5493 component = dynamic_cast<AST_Component *> (component_as_interface);
5495 /*
5496 * Add the component to its definition scope.
5497 */
5498 scope->fe_add_component (component);
5500 // This FE_ComponentHeader class isn't destroyed with the AST.
5501 component_header->destroy ();
5502 delete component_header;
5503 component_header = 0;
5504 }
5506 /*
5507 * Push it on the scope stack.
5508 */
5509 idl_global->scopes ().push (component);
5511 $<dcval>$ = component;
5512 }
5513 '{'
5514 {
5515 idl_global->set_parse_state (IDL_GlobalData::PS_ComponentSqSeen);
5516 }
5517 component_exports
5518 {
5519 idl_global->set_parse_state (IDL_GlobalData::PS_ComponentBodySeen);
5520 }
5521 '}'
5522 {
5523 idl_global->set_parse_state (IDL_GlobalData::PS_ComponentQsSeen);
5525 /*
5526 * Done with this component - pop it off the scopes stack.
5527 */
5528 idl_global->scopes ().pop ();
5530 $$ = $<dcval>2;
5531 }
5532 ;
5534 component_header :
5535 IDL_COMPONENT
5536 defining_id
5537 {
5538 idl_global->set_parse_state (IDL_GlobalData::PS_ComponentIDSeen);
5539 }
5540 component_inheritance_spec
5541 {
5542 idl_global->set_parse_state (IDL_GlobalData::PS_InheritSpecSeen);
5543 }
5544 supports_spec
5545 {
5546 idl_global->set_parse_state (IDL_GlobalData::PS_SupportSpecSeen);
5548 /*
5549 * Create an AST representation of the information in the header
5550 * part of a component.
5551 */
5552 UTL_ScopedName *n = 0;
5553 ACE_NEW_RETURN (n,
5554 UTL_ScopedName ($2,
5555 0),
5556 1);
5557 ACE_NEW_RETURN ($<chval>$,
5558 FE_ComponentHeader (n,
5559 $4,
5560 $6,
5561 false),
5562 1);
5564 if (0 != $6)
5565 {
5566 $6->destroy ();
5567 delete $6;
5568 $6 = 0;
5569 }
5571 if (0 != $4)
5572 {
5573 $4->destroy ();
5574 delete $4;
5575 $4 = 0;
5576 }
5577 }
5578 ;
5580 component_inheritance_spec
5581 : ':'
5582 {
5583 idl_global->set_parse_state (IDL_GlobalData::PS_InheritColonSeen);
5584 }
5585 scoped_name
5586 {
5587 $<idlist>$ = $3;
5588 }
5589 | %empty
5590 {
5591 $$ = 0;
5592 }
5593 ;
5595 component_exports
5596 : component_exports at_least_one_annotation component_export
5597 {
5598 AST_Annotation_Appls *&annotations = $2;
5599 AST_Decl *&node = $3;
5600 if (node)
5601 {
5602 node->annotation_appls (*annotations);
5603 }
5604 else
5605 {
5606 idl_global->err ()-> unsupported_warning (
5607 "Annotating this is not supported");
5608 }
5609 delete annotations;
5610 }
5611 | component_exports component_export
5612 | %empty
5613 ;
5615 component_export
5616 : provides_decl
5617 {
5618 idl_global->set_parse_state (IDL_GlobalData::PS_ProvidesDeclSeen);
5619 }
5620 ';'
5621 {
5622 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
5623 $$ = $1;
5624 }
5625 | uses_decl
5626 {
5627 idl_global->set_parse_state (IDL_GlobalData::PS_UsesDeclSeen);
5628 }
5629 ';'
5630 {
5631 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
5632 $$ = $1;
5633 }
5634 | emits_decl
5635 {
5636 idl_global->set_parse_state (IDL_GlobalData::PS_EmitsDeclSeen);
5637 }
5638 ';'
5639 {
5640 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
5641 $$ = $1;
5642 }
5643 | publishes_decl
5644 {
5645 idl_global->set_parse_state (IDL_GlobalData::PS_PublishesDeclSeen);
5646 }
5647 ';'
5648 {
5649 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
5650 $$ = $1;
5651 }
5652 | consumes_decl
5653 {
5654 idl_global->set_parse_state (IDL_GlobalData::PS_ConsumesDeclSeen);
5655 }
5656 ';'
5657 {
5658 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
5659 $$ = $1;
5660 }
5661 | attribute
5662 {
5663 idl_global->set_parse_state (IDL_GlobalData::PS_AttrDeclSeen);
5664 }
5665 ';'
5666 {
5667 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
5668 $$ = $1;
5669 }
5670 | extended_port_decl
5671 {
5672 idl_global->set_parse_state (IDL_GlobalData::PS_ExtendedPortDeclSeen);
5673 }
5674 ';'
5675 {
5676 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
5677 $$ = $1;
5678 }
5679 ;
5681 provides_decl : IDL_PROVIDES interface_type id
5682 {
5683 UTL_Scope *s = idl_global->scopes ().top_non_null ();
5684 bool so_far_so_good = true;
5685 AST_Decl::NodeType nt = AST_Decl::NT_type;
5686 AST_Param_Holder *ph = 0;
5688 AST_Decl *d =
5689 s->lookup_by_name ($2, true, false);
5691 if (d == 0)
5692 {
5693 idl_global->err ()->lookup_error ($2);
5694 so_far_so_good = false;
5695 }
5696 else
5697 {
5698 int compare = 0;
5699 nt = d->node_type ();
5701 switch (nt)
5702 {
5703 case AST_Decl::NT_interface:
5704 break;
5705 case AST_Decl::NT_param_holder:
5706 ph = dynamic_cast<AST_Param_Holder*> (d);
5707 nt = ph->info ()->type_;
5709 if (nt != AST_Decl::NT_type
5710 && nt != AST_Decl::NT_interface)
5711 {
5712 idl_global->err ()->mismatched_template_param (
5713 ph->info ()->name_.c_str ());
5715 so_far_so_good = false;
5716 }
5718 break;
5719 case AST_Decl::NT_pre_defined:
5720 // Nothing else but CORBA::Object can have
5721 // this identifier.
5722 compare =
5723 ACE_OS::strcmp (d->local_name ()->get_string (),
5724 "Object");
5726 // Simple provides port must use IDL interface
5727 // or CORBA::Object.
5728 if (compare != 0)
5729 {
5730 idl_global->err ()->interface_expected (d);
5731 so_far_so_good = false;
5732 }
5734 break;
5735 default:
5736 idl_global->err ()->interface_expected (d);
5737 so_far_so_good = false;
5738 break;
5739 }
5740 }
5742 AST_Provides *provides = 0;
5744 if (so_far_so_good)
5745 {
5746 AST_Type *port_interface_type =
5747 dynamic_cast<AST_Type*> (d);
5749 // Strip off _cxx_, if any, for port name.
5750 FE_Utils::original_local_name ($3);
5752 UTL_ScopedName sn ($3,
5753 0);
5755 provides = idl_global->gen ()->create_provides (
5756 &sn, port_interface_type);
5758 (void) s->fe_add_provides (provides);
5759 }
5761 $2->destroy ();
5762 delete $2;
5763 $2 = 0;
5765 $3->destroy ();
5766 delete $3;
5767 $3 = 0;
5769 $$ = dynamic_cast<AST_Decl *> (provides);
5770 }
5771 ;
5773 interface_type
5774 : scoped_name
5775 {
5776 // Lookups and checking are done where the 'interface_type'
5777 // token is used, in 'provides_decl' and 'uses_decl'.
5778 $$ = $1;
5779 }
5780 | IDL_OBJECT
5781 {
5782 Identifier *corba_id = 0;
5784 ACE_NEW_RETURN (corba_id,
5785 Identifier ("Object"),
5786 1);
5788 UTL_IdList *conc_name = 0;
5789 ACE_NEW_RETURN (conc_name,
5790 UTL_IdList (corba_id,
5791 0),
5792 1);
5794 ACE_NEW_RETURN (corba_id,
5795 Identifier ("CORBA"),
5796 1);
5798 ACE_NEW_RETURN ($<idlist>$,
5799 UTL_IdList (corba_id,
5800 conc_name),
5801 1);
5802 }
5803 ;
5805 uses_decl : uses_opt_multiple interface_type id
5806 {
5807 UTL_Scope *s = idl_global->scopes ().top_non_null ();
5808 bool so_far_so_good = true;
5809 AST_Decl::NodeType nt = AST_Decl::NT_type;
5810 AST_Param_Holder *ph = 0;
5812 AST_Decl *d =
5813 s->lookup_by_name ($2, true, false);
5815 if (d == 0)
5816 {
5817 idl_global->err ()->lookup_error ($2);
5818 so_far_so_good = false;
5819 }
5820 else
5821 {
5822 int compare = 0;
5823 nt = d->node_type ();
5825 switch (nt)
5826 {
5827 case AST_Decl::NT_interface:
5828 break;
5829 case AST_Decl::NT_param_holder:
5830 ph = dynamic_cast<AST_Param_Holder*> (d);
5831 nt = ph->info ()->type_;
5833 if (nt != AST_Decl::NT_type
5834 && nt != AST_Decl::NT_interface)
5835 {
5836 idl_global->err ()->mismatched_template_param (
5837 ph->info ()->name_.c_str ());
5839 so_far_so_good = false;
5840 }
5842 break;
5843 case AST_Decl::NT_pre_defined:
5844 // Nothing else but CORBA::Object can have
5845 // this identifier.
5846 compare =
5847 ACE_OS::strcmp (d->local_name ()->get_string (),
5848 "Object");
5850 // Simple provides port must use IDL interface
5851 // or CORBA::Object.
5852 if (compare != 0)
5853 {
5854 idl_global->err ()->interface_expected (d);
5855 so_far_so_good = false;
5856 }
5858 break;
5859 default:
5860 idl_global->err ()->interface_expected (d);
5861 so_far_so_good = false;
5862 break;
5863 }
5864 }
5866 AST_Uses *uses = 0;
5868 if (so_far_so_good)
5869 {
5870 AST_Type *port_interface_type =
5871 dynamic_cast<AST_Type*> (d);
5873 // Strip off _cxx_, if any, for port name.
5874 FE_Utils::original_local_name ($3);
5876 UTL_ScopedName sn ($3,
5877 0);
5879 uses = idl_global->gen ()->create_uses (
5880 &sn, port_interface_type, $1);
5881 s->fe_add_uses (uses);
5883 AST_Component *c =
5884 dynamic_cast<AST_Component*> (s);
5886 if (c != 0
5887 && uses->is_multiple ()
5888 && !idl_global->using_ifr_backend ()
5889 && !idl_global->ignore_idl3 ()
5890 && nt != AST_Decl::NT_param_holder)
5891 {
5892 // These datatypes must be created in the
5893 // front end so they can be looked up
5894 // when compiling the generated executor IDL.
5895 FE_Utils::create_uses_multiple_stuff (c, uses);
5896 }
5897 }
5899 $2->destroy ();
5900 delete $2;
5901 $2 = 0;
5903 $3->destroy ();
5904 delete $3;
5905 $3 = 0;
5907 $$ = uses;
5908 }
5909 ;
5911 uses_opt_multiple
5912 : IDL_USES opt_multiple
5913 {
5914 // We use this extra rule here to use in both uses_decl and
5915 // extended_uses_decl, so the LALR(1) parser can avoid conflicts.
5916 $$ = $2;
5917 }
5918 ;
5920 opt_multiple
5921 : IDL_MULTIPLE
5922 {
5923 $$ = true;
5924 }
5925 | %empty
5926 {
5927 $$ = false;
5928 }
5929 ;
5931 emits_decl
5932 : IDL_EMITS scoped_name id
5933 {
5934 UTL_Scope *s = idl_global->scopes ().top_non_null ();
5935 bool so_far_so_good = true;
5936 AST_Decl::NodeType nt = AST_Decl::NT_type;
5937 AST_Param_Holder *ph = 0;
5939 AST_Decl *d =
5940 s->lookup_by_name ($2, true, false);
5942 if (0 == d)
5943 {
5944 idl_global->err ()->lookup_error ($2);
5945 so_far_so_good = false;
5946 }
5947 else
5948 {
5949 nt = d->node_type ();
5951 switch (nt)
5952 {
5953 case AST_Decl::NT_eventtype:
5954 break;
5955 case AST_Decl::NT_param_holder:
5956 ph = dynamic_cast<AST_Param_Holder*> (d);
5957 nt = ph->info ()->type_;
5959 if (nt != AST_Decl::NT_type
5960 && nt != AST_Decl::NT_eventtype)
5961 {
5962 idl_global->err ()->mismatched_template_param (
5963 ph->info ()->name_.c_str ());
5965 so_far_so_good = false;
5966 }
5968 break;
5969 default:
5970 idl_global->err ()->eventtype_expected (d);
5971 so_far_so_good = false;
5972 break;
5973 }
5974 }
5976 AST_Emits *e = 0;
5978 if (so_far_so_good)
5979 {
5980 AST_Type *event_type =
5981 dynamic_cast<AST_Type*> (d);
5983 // Strip off _cxx_, if any, for port name.
5984 FE_Utils::original_local_name ($3);
5986 UTL_ScopedName sn ($3,
5987 0);
5989 e = idl_global->gen ()->create_emits (&sn, event_type);
5991 (void) s->fe_add_emits (e);
5992 }
5994 $2->destroy ();
5995 delete $2;
5996 $2 = 0;
5998 $3->destroy ();
5999 delete $3;
6000 $3 = 0;
6002 $$ = e;
6003 }
6004 ;
6006 publishes_decl
6007 : IDL_PUBLISHES scoped_name id
6008 {
6009 UTL_Scope *s = idl_global->scopes ().top_non_null ();
6010 bool so_far_so_good = true;
6011 AST_Decl::NodeType nt = AST_Decl::NT_type;
6012 AST_Param_Holder *ph = 0;
6014 AST_Decl *d =
6015 s->lookup_by_name ($2, true, false);
6017 if (0 == d)
6018 {
6019 idl_global->err ()->lookup_error ($2);
6020 so_far_so_good = false;
6021 }
6022 else
6023 {
6024 nt = d->node_type ();
6026 switch (nt)
6027 {
6028 case AST_Decl::NT_eventtype:
6029 break;
6030 case AST_Decl::NT_param_holder:
6031 ph = dynamic_cast<AST_Param_Holder*> (d);
6032 nt = ph->info ()->type_;
6034 if (nt != AST_Decl::NT_type
6035 && nt != AST_Decl::NT_eventtype)
6036 {
6037 idl_global->err ()->mismatched_template_param (
6038 ph->info ()->name_.c_str ());
6040 so_far_so_good = false;
6041 }
6043 break;
6044 default:
6045 idl_global->err ()->eventtype_expected (d);
6046 so_far_so_good = false;
6047 break;
6048 }
6049 }
6051 AST_Publishes *p = 0;
6053 if (so_far_so_good)
6054 {
6055 AST_Type *event_type =
6056 dynamic_cast<AST_Type*> (d);
6058 // Strip off _cxx_, if any, for port name.
6059 FE_Utils::original_local_name ($3);
6061 UTL_ScopedName sn ($3, 0);
6062 p = idl_global->gen ()->create_publishes (&sn, event_type);
6063 s->fe_add_publishes (p);
6064 }
6066 $2->destroy ();
6067 delete $2;
6068 $2 = 0;
6070 $3->destroy ();
6071 delete $3;
6072 $3 = 0;
6074 $$ = p;
6075 }
6076 ;
6078 consumes_decl
6079 : IDL_CONSUMES scoped_name id
6080 {
6081 UTL_Scope *s = idl_global->scopes ().top_non_null ();
6082 bool so_far_so_good = true;
6083 AST_Decl::NodeType nt = AST_Decl::NT_type;
6084 AST_Param_Holder *ph = 0;
6086 AST_Decl *d =
6087 s->lookup_by_name ($2, true, false);
6089 if (0 == d)
6090 {
6091 idl_global->err ()->lookup_error ($2);
6092 so_far_so_good = false;
6093 }
6094 else
6095 {
6096 nt = d->node_type ();
6098 switch (nt)
6099 {
6100 case AST_Decl::NT_eventtype:
6101 break;
6102 case AST_Decl::NT_param_holder:
6103 ph = dynamic_cast<AST_Param_Holder*> (d);
6104 nt = ph->info ()->type_;
6106 if (nt != AST_Decl::NT_type
6107 && nt != AST_Decl::NT_eventtype)
6108 {
6109 idl_global->err ()->mismatched_template_param (
6110 ph->info ()->name_.c_str ());
6112 so_far_so_good = false;
6113 }
6115 break;
6116 default:
6117 idl_global->err ()->eventtype_expected (d);
6118 so_far_so_good = false;
6119 break;
6120 }
6121 }
6123 AST_Consumes *c = 0;
6125 if (so_far_so_good)
6126 {
6127 AST_Type *event_type =
6128 dynamic_cast<AST_Type*> (d);
6130 // Strip off _cxx_, if any, for port name.
6131 FE_Utils::original_local_name ($3);
6133 UTL_ScopedName sn ($3,
6134 0);
6136 c = idl_global->gen ()->create_consumes (&sn, event_type);
6138 (void) s->fe_add_consumes (c);
6139 }
6141 $2->destroy ();
6142 delete $2;
6143 $2 = 0;
6145 $3->destroy ();
6146 delete $3;
6147 $3 = 0;
6149 $$ = c;
6150 }
6151 ;
6153 home_decl
6154 : home_header
6155 {
6156 UTL_Scope *s = idl_global->scopes ().top_non_null ();
6157 AST_Home *h = 0;
6159 /*
6160 * Make a new home node and add it to the enclosing scope.
6161 */
6162 if (s != 0 && $1 != 0)
6163 {
6164 h =
6165 idl_global->gen ()->create_home (
6166 $1->name (),
6167 $1->base_home (),
6168 $1->managed_component (),
6169 $1->primary_key (),
6170 $1->supports (),
6171 $1->n_supports (),
6172 $1->supports_flat (),
6173 $1->n_supports_flat ()
6174 );
6175 /*
6176 * Add the home to its definition scope.
6177 */
6178 (void) s->fe_add_home (h);
6180 // This FE_HomeHeader class isn't destroyed with the AST.
6181 $1->destroy ();
6182 delete $1;
6183 $1 = 0;
6184 }
6186 /*
6187 * Push it on the scope stack.
6188 */
6189 idl_global->scopes ().push (h);
6190 }
6191 home_body
6192 {
6193 /*
6194 * Done with this component - pop it off the scopes stack.
6195 */
6196 idl_global->scopes ().pop ();
6198 $$ = 0;
6199 }
6200 ;
6202 home_header
6203 : IDL_HOME
6204 {
6205 idl_global->set_parse_state (IDL_GlobalData::PS_HomeSeen);
6206 }
6207 defining_id
6208 {
6209 idl_global->set_parse_state (IDL_GlobalData::PS_HomeIDSeen);
6210 }
6211 home_inheritance_spec
6212 {
6213 idl_global->set_parse_state (IDL_GlobalData::PS_InheritSpecSeen);
6214 }
6215 supports_spec
6216 {
6217 idl_global->set_parse_state (IDL_GlobalData::PS_SupportSpecSeen);
6218 }
6219 IDL_MANAGES
6220 {
6221 idl_global->set_parse_state (IDL_GlobalData::PS_ManagesSeen);
6222 }
6223 scoped_name
6224 {
6225 idl_global->set_parse_state (IDL_GlobalData::PS_ManagesIDSeen);
6226 }
6227 primary_key_spec
6228 {
6229 idl_global->set_parse_state (IDL_GlobalData::PS_PrimaryKeySpecSeen);
6231 /*
6232 * Create an AST representation of the information in the header
6233 * part of a component home.
6234 */
6235 UTL_ScopedName *n = 0;
6236 ACE_NEW_RETURN (n,
6237 UTL_ScopedName ($3, 0),
6238 1);
6240 ACE_NEW_RETURN ($<hhval>$,
6241 FE_HomeHeader (n,
6242 $5,
6243 $7,
6244 $11,
6245 $13),
6246 1);
6248 $11->destroy ();
6249 delete $11;
6250 $11 = 0;
6252 if (0 != $5)
6253 {
6254 $5->destroy ();
6255 delete $5;
6256 $5 = 0;
6257 }
6259 if (0 != $13)
6260 {
6261 $13->destroy ();
6262 delete $13;
6263 $13 = 0;
6264 }
6266 if (0 != $7)
6267 {
6268 $7->destroy ();
6269 delete $7;
6270 $7 = 0;
6271 }
6272 }
6273 ;
6275 home_inheritance_spec
6276 : ':'
6277 {
6278 idl_global->set_parse_state (IDL_GlobalData::PS_InheritColonSeen);
6279 }
6280 scoped_name
6281 {
6282 $<idlist>$ = $3;
6283 }
6284 | %empty
6285 {
6286 $$ = 0;
6287 }
6288 ;
6290 primary_key_spec
6291 : IDL_PRIMARYKEY
6292 scoped_name
6293 {
6294 $$ = $2;
6295 }
6296 | %empty
6297 {
6298 $$ = 0;
6299 }
6300 ;
6302 home_body :
6303 '{'
6304 {
6305 idl_global->set_parse_state (IDL_GlobalData::PS_HomeSqSeen);
6306 }
6307 home_exports
6308 {
6309 idl_global->set_parse_state (IDL_GlobalData::PS_HomeBodySeen);
6310 }
6311 '}'
6312 {
6313 idl_global->set_parse_state (IDL_GlobalData::PS_HomeQsSeen);
6314 }
6315 ;
6317 home_exports
6318 : home_exports home_export
6319 | %empty
6320 ;
6322 home_export
6323 : export
6324 | factory_decl
6325 {
6326 idl_global->set_parse_state (IDL_GlobalData::PS_FactoryDeclSeen);
6327 }
6328 ';'
6329 {
6330 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
6331 }
6332 | finder_decl
6333 {
6334 idl_global->set_parse_state (IDL_GlobalData::PS_FinderDeclSeen);
6335 }
6336 ';'
6337 {
6338 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
6339 }
6340 ;
6342 factory_decl :
6343 IDL_FACTORY
6344 defining_id
6345 {
6346 UTL_Scope *s = idl_global->scopes ().top_non_null ();
6347 UTL_ScopedName n ($2,
6348 0);
6349 idl_global->set_parse_state (IDL_GlobalData::PS_OpIDSeen);
6351 /*
6352 * Create a node representing a factory operation
6353 * and add it to the enclosing scope.
6354 */
6355 AST_Factory *f = idl_global->gen ()->create_factory (&n);
6356 (void) s->fe_add_factory (f);
6358 $2->destroy ();
6359 delete $2;
6360 $2 = 0;
6362 /*
6363 * Push the factory scope onto the scopes stack.
6364 */
6365 idl_global->scopes ().push (f);
6366 }
6367 init_parameter_list
6368 {
6369 idl_global->set_parse_state (IDL_GlobalData::PS_OpParsCompleted);
6370 }
6371 opt_raises
6372 {
6373 UTL_Scope *s = idl_global->scopes ().top_non_null ();
6374 idl_global->set_parse_state (IDL_GlobalData::PS_OpRaiseCompleted);
6376 /*
6377 * Add exceptions and context to the factory.
6378 */
6379 if ($6 != 0)
6380 {
6381 (void) s->fe_add_exceptions ($6);
6382 }
6384 /*
6385 * Done with this factory. Pop its scope from the scopes stack.
6386 */
6387 idl_global->scopes ().pop ();
6388 }
6389 ;
6391 finder_decl :
6392 IDL_FINDER
6393 defining_id
6394 {
6395 UTL_Scope *s = idl_global->scopes ().top_non_null ();
6396 UTL_ScopedName n ($2,
6397 0);
6399 idl_global->set_parse_state (IDL_GlobalData::PS_OpIDSeen);
6401 /*
6402 * Create a node representing a home finder
6403 * and add it to the enclosing scope.
6404 */
6405 AST_Finder *f =
6406 idl_global->gen ()->create_finder (&n);
6408 (void) s->fe_add_finder (f);
6411 $2->destroy ();
6412 delete $2;
6413 $2 = 0;
6415 /*
6416 * Push the operation scope onto the scopes stack.
6417 */
6418 idl_global->scopes ().push (f);
6419 }
6420 init_parameter_list
6421 {
6422 idl_global->set_parse_state (IDL_GlobalData::PS_OpParsCompleted);
6423 }
6424 opt_raises
6425 {
6426 UTL_Scope *s = idl_global->scopes ().top_non_null ();
6427 idl_global->set_parse_state (IDL_GlobalData::PS_OpRaiseCompleted);
6429 /*
6430 * Add exceptions and context to the finder.
6431 */
6432 if ($6 != 0)
6433 {
6434 (void) s->fe_add_exceptions ($6);
6435 }
6437 /*
6438 * Done with this operation. Pop its scope from the scopes stack.
6439 */
6440 idl_global->scopes ().pop ();
6441 }
6442 ;
6444 event
6445 : event_decl
6446 | event_abs_decl
6447 | event_forward_decl
6448 ;
6450 event_forward_decl
6451 : event_abs_forward_decl
6452 | event_concrete_forward_decl
6453 ;
6455 event_concrete_forward_decl :
6456 IDL_EVENTTYPE
6457 defining_id
6458 {
6459 UTL_Scope *s = idl_global->scopes ().top_non_null ();
6460 UTL_ScopedName n ($2,
6461 0);
6462 AST_EventTypeFwd *f = 0;
6463 idl_global->set_parse_state (IDL_GlobalData::PS_EventTypeForwardSeen);
6465 /*
6466 * Create a node representing a forward declaration of an
6467 * eventtype. Store it in the enclosing scope
6468 */
6469 if (s != 0)
6470 {
6471 f = idl_global->gen ()->create_eventtype_fwd (&n,
6472 false);
6473 (void) s->fe_add_valuetype_fwd (f);
6474 }
6476 $2->destroy ();
6477 delete $2;
6478 $2 = 0;
6480 $$ = 0;
6481 }
6482 ;
6484 event_abs_forward_decl :
6485 IDL_ABSTRACT
6486 IDL_EVENTTYPE
6487 defining_id
6488 {
6489 UTL_Scope *s = idl_global->scopes ().top_non_null ();
6490 UTL_ScopedName n ($3,
6491 0);
6492 AST_EventTypeFwd *f = 0;
6493 idl_global->set_parse_state (IDL_GlobalData::PS_EventTypeForwardSeen);
6495 /*
6496 * Create a node representing a forward declaration of an
6497 * eventtype. Store it in the enclosing scope
6498 */
6499 if (s != 0)
6500 {
6501 f = idl_global->gen ()->create_eventtype_fwd (&n,
6502 true);
6503 (void) s->fe_add_valuetype_fwd (f);
6504 }
6506 $3->destroy ();
6507 delete $3;
6508 $3 = 0;
6510 $$ = 0;
6511 }
6512 ;
6514 event_abs_decl :
6515 event_abs_header
6516 event_rest_of_header
6517 {
6518 UTL_Scope *s = idl_global->scopes ().top_non_null ();
6519 AST_EventType *e = 0;
6520 AST_Interface *i = 0;
6522 if (s != 0 && $1 != 0)
6523 {
6524 UTL_ScopedName sn ($1,
6525 0);
6526 e =
6527 idl_global->gen ()->create_eventtype (
6528 &sn,
6529 $2->inherits (),
6530 $2->n_inherits (),
6531 $2->inherits_concrete (),
6532 $2->inherits_flat (),
6533 $2->n_inherits_flat (),
6534 $2->supports (),
6535 $2->n_supports (),
6536 $2->supports_concrete (),
6537 true,
6538 false,
6539 false
6540 );
6541 i = dynamic_cast<AST_Interface*> (e);
6542 AST_Interface::fwd_redefinition_helper (i,
6543 s);
6544 /*
6545 * Add the eventetype to its definition scope
6546 */
6547 e = dynamic_cast<AST_EventType*> (i);
6548 (void) s->fe_add_eventtype (e);
6549 }
6551 /*
6552 * Push it on the scope stack.
6553 */
6554 idl_global->scopes ().push (e);
6556 $1->destroy ();
6557 delete $1;
6558 $1 = 0;
6559 }
6560 '{'
6561 {
6562 idl_global->set_parse_state (IDL_GlobalData::PS_EventTypeSqSeen);
6563 }
6564 exports
6565 {
6566 idl_global->set_parse_state (IDL_GlobalData::PS_EventTypeBodySeen);
6567 }
6568 '}'
6569 {
6570 idl_global->set_parse_state (IDL_GlobalData::PS_EventTypeQsSeen);
6572 /*
6573 * Done with this eventtype - pop it off the scopes stack.
6574 */
6575 idl_global->scopes ().pop ();
6577 $$ = 0;
6578 }
6579 ;
6581 event_abs_header :
6582 IDL_ABSTRACT
6583 IDL_EVENTTYPE
6584 defining_id
6585 {
6586 $$ = $3;
6587 }
6588 ;
6590 event_custom_header :
6591 IDL_CUSTOM
6592 IDL_EVENTTYPE
6593 defining_id
6594 {
6595 idl_global->set_parse_state (IDL_GlobalData::PS_EventTypeIDSeen);
6597 ACE_DEBUG ((LM_DEBUG,
6598 ACE_TEXT ("error in %C line %d\n"),
6599 idl_global->filename ()->get_string (),
6600 idl_global->lineno ()));
6601 ACE_DEBUG ((LM_DEBUG,
6602 ACE_TEXT ("Sorry, I (TAO_IDL) can't handle")
6603 ACE_TEXT (" custom yet\n")));
6604 $$ = 0;
6605 }
6606 ;
6608 event_plain_header :
6609 IDL_EVENTTYPE
6610 defining_id
6611 {
6612 idl_global->set_parse_state (IDL_GlobalData::PS_EventTypeIDSeen);
6614 $$ = $2;
6615 }
6616 ;
6618 event_rest_of_header :
6619 inheritance_spec
6620 {
6621 idl_global->set_parse_state (IDL_GlobalData::PS_InheritSpecSeen);
6622 }
6623 supports_spec
6624 {
6625 idl_global->set_parse_state (IDL_GlobalData::PS_SupportSpecSeen);
6627 ACE_NEW_RETURN ($<vhval>$,
6628 FE_OBVHeader (
6629 0,
6630 $1,
6631 $3,
6632 $1
6633 ? $1->truncatable ()
6634 : false,
6635 true),
6636 1);
6638 if (0 != $3)
6639 {
6640 $3->destroy ();
6641 delete $3;
6642 $3 = 0;
6643 }
6645 if (0 != $1)
6646 {
6647 $1->destroy ();
6648 delete $1;
6649 $1 = 0;
6650 }
6651 }
6652 ;
6654 event_decl :
6655 event_header
6656 event_rest_of_header
6657 {
6658 UTL_Scope *scope = idl_global->scopes ().top_non_null ();
6659 Identifier *&event_id = $1;
6660 FE_OBVHeader *&event_header = $2;
6661 AST_EventType *eventtype = 0;
6663 if (scope && event_header)
6664 {
6665 // We create the scoped name here instead of with the
6666 // FE_OBVHeader because there is a token for it only here.
6667 UTL_ScopedName sn (event_id, 0);
6668 eventtype = idl_global->gen ()->create_eventtype (
6669 &sn,
6670 event_header->inherits (),
6671 event_header->n_inherits (),
6672 event_header->inherits_concrete (),
6673 event_header->inherits_flat (),
6674 event_header->n_inherits_flat (),
6675 event_header->supports (),
6676 event_header->n_supports (),
6677 event_header->supports_concrete (),
6678 false,
6679 event_header->truncatable (),
6680 false);
6681 AST_Interface *eventtype_as_interface =
6682 dynamic_cast<AST_Interface *> (eventtype);
6683 AST_Interface::fwd_redefinition_helper (
6684 eventtype_as_interface, scope);
6685 eventtype = dynamic_cast<AST_EventType *> (eventtype_as_interface);
6687 /*
6688 * Add the eventetype to its definition scope
6689 */
6690 scope->fe_add_eventtype (eventtype);
6692 // FE_OBVHeader is not automatically destroyed in the AST
6693 event_header->destroy ();
6694 delete event_header;
6695 event_header = 0;
6697 sn.destroy ();
6698 }
6700 /*
6701 * Push it on the scope stack.
6702 */
6703 idl_global->scopes ().push (eventtype);
6705 $<dcval>$ = eventtype;
6706 }
6707 '{'
6708 {
6709 idl_global->set_parse_state (IDL_GlobalData::PS_EventTypeSqSeen);
6710 }
6711 value_elements
6712 {
6713 idl_global->set_parse_state (IDL_GlobalData::PS_EventTypeBodySeen);
6714 }
6715 '}'
6716 {
6717 idl_global->set_parse_state (IDL_GlobalData::PS_EventTypeQsSeen);
6719 /*
6720 * Done with this eventtype - pop it off the scopes stack.
6721 */
6722 idl_global->scopes ().pop ();
6724 $$ = $<dcval>3;
6725 }
6726 ;
6728 event_header
6729 : event_custom_header
6730 {
6731 $$ = $1;
6732 }
6733 | event_plain_header
6734 {
6735 $$ = $1;
6736 }
6737 ;
6739 formal_parameter_type
6740 : IDL_TYPENAME
6741 {
6742 $<ntval>$ = AST_Decl::NT_type;
6743 }
6744 | IDL_STRUCT
6745 {
6746 $<ntval>$ = AST_Decl::NT_struct;
6747 }
6748 | IDL_UNION
6749 {
6750 $<ntval>$ = AST_Decl::NT_union;
6751 }
6752 | IDL_EVENTTYPE
6753 {
6754 $<ntval>$ = AST_Decl::NT_eventtype;
6755 }
6756 | IDL_SEQUENCE
6757 {
6758 $<ntval>$ = AST_Decl::NT_sequence;
6759 }
6760 | IDL_MAP
6761 {
6762 $<ntval>$ = AST_Decl::NT_map;
6763 }
6764 | IDL_INTERFACE
6765 {
6766 $<ntval>$ = AST_Decl::NT_interface;
6767 }
6768 | IDL_VALUETYPE
6769 {
6770 $<ntval>$ = AST_Decl::NT_valuetype;
6771 }
6772 | IDL_ENUM
6773 {
6774 $<ntval>$ = AST_Decl::NT_enum;
6775 }
6776 | IDL_EXCEPTION
6777 {
6778 $<ntval>$ = AST_Decl::NT_except;
6779 }
6780 | IDL_CONST const_type
6781 {
6782 $<ntval>$ = AST_Decl::NT_const;
6783 t_param_const_type = $2;
6784 }
6785 ;
6787 at_least_one_formal_parameter
6788 : formal_parameter formal_parameters
6789 {
6790 if ($2 == 0)
6791 {
6792 ACE_NEW_RETURN ($2, FE_Utils::T_PARAMLIST_INFO, 1);
6793 }
6795 $2->enqueue_head (*$1);
6796 delete $1;
6797 $1 = 0;
6799 // The param added above is always the last one parsed,
6800 // so we check for matches between sequence<T> & T here.
6801 ACE_CString bad_id =
6802 FE_Utils::check_for_seq_of_param (
6803 $2);
6805 if (!bad_id.empty ())
6806 {
6807 delete $2;
6808 $2 = 0;
6810 idl_global->err ()->mismatch_seq_of_param (bad_id.c_str ());
6811 return 1;
6812 }
6814 $$ = $2;
6815 }
6816 ;
6818 formal_parameters
6819 : formal_parameters ',' formal_parameter
6820 {
6821 if ($1 == 0)
6822 {
6823 ACE_NEW_RETURN ($1, FE_Utils::T_PARAMLIST_INFO, 1);
6824 }
6826 $1->enqueue_tail (*$3);
6827 $$ = $1;
6829 delete $3;
6830 $3 = 0;
6831 }
6832 | %empty
6833 {
6834 $$ = 0;
6835 }
6836 ;
6838 formal_parameter
6839 : formal_parameter_type IDENTIFIER
6840 {
6842 ACE_NEW_RETURN ($$,
6843 FE_Utils::T_Param_Info,
6844 1);
6846 AST_Decl::NodeType nt = $1;
6848 $$->type_ = nt;
6849 $$->name_ = $2;
6850 ACE::strdelete ($2);
6851 $2 = 0;
6853 if (nt == AST_Decl::NT_const)
6854 {
6855 $$->const_type_ = t_param_const_type;
6856 $$->enum_const_type_decl_ =
6857 tao_enum_constant_decl;
6859 // Reset these values.
6860 t_param_const_type = AST_Expression::EV_none;
6861 tao_enum_constant_decl = 0;
6862 }
6863 }
6864 | IDL_SEQUENCE '<' IDENTIFIER '>' IDENTIFIER
6865 {
6866 ACE_NEW_RETURN ($$,
6867 FE_Utils::T_Param_Info,
6868 1);
6870 $$->type_ = AST_Decl::NT_sequence;
6871 $$->seq_param_ref_ = $3;
6872 $$->name_ += $5;
6874 ACE::strdelete ($3);
6875 $3 = 0;
6876 ACE::strdelete ($5);
6877 $5 = 0;
6878 }
6879 ;
6881 at_least_one_formal_parameter_name
6882 : formal_parameter_name formal_parameter_names
6883 {
6884 ACE_NEW_RETURN ($$, UTL_StrList ($1, $2), 1);
6885 }
6886 ;
6888 formal_parameter_names
6889 : formal_parameter_names ',' formal_parameter_name
6890 {
6891 UTL_StrList *sl = 0;
6892 ACE_NEW_RETURN (sl, UTL_StrList ($3, 0), 1);
6894 if ($1 == 0)
6895 {
6896 $$ = sl;
6897 }
6898 else
6899 {
6900 $1->nconc (sl);
6901 $$ = $1;
6902 }
6903 }
6904 | %empty
6905 {
6906 $$ = 0;
6907 }
6908 ;
6910 formal_parameter_name
6911 : IDENTIFIER
6912 {
6913 ACE_NEW_RETURN ($$,
6914 UTL_String ($1, true),
6915 1);
6916 }
6917 ;
6919 porttype_decl
6920 : IDL_PORTTYPE
6921 {
6922 idl_global->set_parse_state (IDL_GlobalData::PS_PorttypeSeen);
6923 }
6924 IDENTIFIER
6925 {
6926 char *&id_value = $3;
6927 idl_global->set_parse_state (IDL_GlobalData::PS_PorttypeIDSeen);
6928 UTL_Scope *scope = idl_global->scopes ().top_non_null ();
6930 Identifier id (id_value);
6931 ACE::strdelete (id_value);
6932 id_value = 0;
6934 UTL_ScopedName scoped_name (&id, 0);
6935 AST_PortType *porttype = idl_global->gen ()->create_porttype (
6936 &scoped_name);
6937 scope->fe_add_porttype (porttype);
6938 $<dcval>$ = porttype;
6940 // Push it on the scopes stack.
6941 idl_global->scopes ().push (porttype);
6942 }
6943 '{'
6944 {
6945 idl_global->set_parse_state (IDL_GlobalData::PS_PorttypeSqSeen);
6946 }
6947 /**
6948 * NOTE: IDL4.2 spec has a different definition of what can go inside a
6949 * portype.
6950 */
6951 at_least_one_port_export
6952 {
6953 idl_global->set_parse_state (IDL_GlobalData::PS_PorttypeBodySeen);
6954 }
6955 '}'
6956 {
6957 idl_global->set_parse_state (IDL_GlobalData::PS_PorttypeQsSeen);
6959 // Done with this port type - pop it off the scopes stack.
6960 idl_global->scopes ().pop ();
6962 $$ = $<dcval>4;
6963 }
6964 ;
6966 at_least_one_port_export
6967 : port_exports at_least_one_annotation port_export
6968 {
6969 AST_Annotation_Appls *&annotations = $2;
6970 AST_Decl *&node = $3;
6971 if (node)
6972 {
6973 node->annotation_appls (*annotations);
6974 }
6975 else
6976 {
6977 idl_global->err ()-> unsupported_warning (
6978 "Annotating this is not supported");
6979 }
6980 delete annotations;
6981 }
6982 | port_exports port_export
6983 ;
6985 port_exports
6986 : at_least_one_port_export
6987 | %empty
6988 ;
6990 port_export
6991 : provides_decl ';'
6992 | uses_decl ';'
6993 | attribute
6994 {
6995 idl_global->set_parse_state (IDL_GlobalData::PS_AttrDeclSeen);
6996 }
6997 ';'
6998 {
6999 $$ = $1;
7000 }
7001 ;
7003 extended_port_decl
7004 : IDL_PORT scoped_name IDENTIFIER
7005 {
7006 idl_global->set_parse_state (IDL_GlobalData::PS_ExtendedPortDeclSeen);
7007 UTL_Scope *s = idl_global->scopes ().top_non_null ();
7008 AST_Decl *d =
7009 s->lookup_by_name ($2);
7010 AST_PortType *pt = 0;
7011 bool so_far_so_good = true;
7013 if (d == 0)
7014 {
7015 idl_global->err ()->lookup_error ($2);
7016 so_far_so_good = false;
7017 }
7018 else
7019 {
7020 pt = dynamic_cast<AST_PortType*> (d);
7022 if (pt == 0)
7023 {
7024 idl_global->err ()->error1 (UTL_Error::EIDL_PORTTYPE_EXPECTED,
7025 d);
7026 so_far_so_good = false;
7027 }
7028 }
7030 AST_Extended_Port *ep = 0;
7032 if (so_far_so_good)
7033 {
7034 Identifier id ($3);
7035 ACE::strdelete ($3);
7036 $3 = 0;
7038 UTL_ScopedName sn (&id, 0);
7039 ep = idl_global->gen ()->create_extended_port (&sn, pt);
7040 s->fe_add_extended_port (ep);
7042 // Create (in the AST) the struct(s) and sequence(s)
7043 // needed for multiplex uses ports, if any.
7044 for (UTL_ScopeActiveIterator i (pt, UTL_Scope::IK_decls);
7045 !i.is_done ();
7046 i.next ())
7047 {
7048 d = i.item ();
7050 AST_Uses *u = dynamic_cast<AST_Uses*> (d);
7052 if (u != 0 && u->is_multiple ())
7053 {
7054 AST_Component *c =
7055 dynamic_cast<AST_Component*> (s);
7057 FE_Utils::create_uses_multiple_stuff (
7058 c,
7059 u,
7060 id.get_string ());
7061 }
7062 }
7063 }
7065 $2->destroy ();
7066 delete $2;
7067 $2 = 0;
7069 $$ = ep;
7070 }
7071 | IDL_MIRRORPORT scoped_name IDENTIFIER
7072 {
7073 idl_global->set_parse_state (IDL_GlobalData::PS_MirrorPortDeclSeen);
7074 UTL_Scope *s = idl_global->scopes ().top_non_null ();
7075 AST_Decl *d =
7076 s->lookup_by_name ($2);
7077 AST_PortType *pt = 0;
7078 bool so_far_so_good = true;
7080 if (d == 0)
7081 {
7082 idl_global->err ()->lookup_error ($2);
7083 so_far_so_good = false;
7084 }
7085 else
7086 {
7087 pt = dynamic_cast<AST_PortType*> (d);
7089 if (pt == 0)
7090 {
7091 idl_global->err ()->error1 (UTL_Error::EIDL_PORTTYPE_EXPECTED,
7092 d);
7093 so_far_so_good = false;
7094 }
7095 }
7097 AST_Mirror_Port *mp = 0;
7099 if (so_far_so_good)
7100 {
7101 Identifier id ($3);
7102 ACE::strdelete ($3);
7103 $3 = 0;
7105 UTL_ScopedName sn (&id, 0);
7106 mp = idl_global->gen ()->create_mirror_port (&sn, pt);
7107 s->fe_add_mirror_port (mp);
7108 }
7110 $2->destroy ();
7111 delete $2;
7112 $2 = 0;
7114 $$ = mp;
7115 }
7116 ;
7118 at_least_one_actual_parameter
7119 : annotations_maybe actual_parameter actual_parameters
7120 {
7121 if ($3 == 0)
7122 {
7123 ACE_NEW_RETURN ($3,
7124 FE_Utils::T_ARGLIST,
7125 1);
7126 }
7128 delete $1;
7129 $3->enqueue_head ($2);
7130 $<alval>$ = $3;
7131 }
7132 ;
7134 actual_parameters
7135 : actual_parameters ',' annotations_maybe actual_parameter
7136 {
7137 if ($1 == 0)
7138 {
7139 ACE_NEW_RETURN ($1,
7140 FE_Utils::T_ARGLIST,
7141 1);
7142 }
7144 delete $3;
7145 $1->enqueue_tail ($4);
7146 $<alval>$ = $1;
7147 }
7148 | %empty
7149 {
7150 $<alval>$ = 0;
7151 }
7152 ;
7154 actual_parameter
7155 : expression
7156 {
7157 // To avoid grammar conflicts with this LALR(1) parser,
7158 // we take advantage of the fact that an expression can
7159 // be a scoped name. At that lower level, we create an
7160 // expression containing the scoped name, and at a
7161 // higher lever, deduce that it's not supposed to be
7162 // a constant and look up the type to add to the template
7163 // arg list.
7164 AST_Expression *ex = $1;
7165 UTL_ScopedName *sn = ex->n ();
7166 AST_Decl *d = 0;
7167 UTL_Scope *s = idl_global->scopes ().top_non_null ();
7169 if (sn != 0)
7170 {
7171 d = s->lookup_by_name (sn);
7173 if (d == 0)
7174 {
7175 idl_global->err ()->lookup_error (sn);
7176 return 1;
7177 }
7178 else
7179 {
7180 AST_Decl::NodeType nt = d->node_type ();
7182 if (nt == AST_Decl::NT_enum_val)
7183 {
7184 $1->evaluate (
7185 AST_Expression::EK_const);
7187 $<dcval>$ =
7188 idl_global->gen ()->create_constant (
7189 $1->ev ()->et,
7190 $1,
7191 sn);
7192 }
7193 else
7194 {
7195 $<dcval>$ = d;
7196 }
7197 }
7198 }
7199 else
7200 {
7201 $1->evaluate (
7202 AST_Expression::EK_const);
7204 $<dcval>$ =
7205 idl_global->gen ()->create_constant (
7206 $1->ev ()->et,
7207 $1,
7208 0);
7209 }
7210 }
7211 ;
7213 connector_decl
7214 : connector_header connector_body
7215 {
7216 $$ = 0;
7217 }
7218 ;
7220 connector_header
7221 : IDL_CONNECTOR
7222 {
7223 idl_global->set_parse_state (IDL_GlobalData::PS_ConnectorSeen);
7224 }
7225 annotations_maybe IDENTIFIER
7226 {
7227 idl_global->set_parse_state (IDL_GlobalData::PS_ConnectorIDSeen);
7228 }
7229 component_inheritance_spec
7230 {
7231 UTL_Scope *s = idl_global->scopes ().top_non_null ();
7232 AST_Connector *parent = 0;
7233 bool so_far_so_good = true;
7235 Identifier id ($4);
7236 ACE::strdelete ($4);
7237 $4 = 0;
7239 UTL_ScopedName sn (&id, 0);
7241 if ($6 != 0)
7242 {
7243 AST_Decl *d =
7244 s->lookup_by_name ($6);
7246 if (d == 0)
7247 {
7248 idl_global->err ()->lookup_error ($6);
7249 so_far_so_good = false;
7250 }
7252 parent =
7253 dynamic_cast<AST_Connector*> (d);
7255 if (parent == 0)
7256 {
7257 idl_global->err ()->error1 (
7258 UTL_Error::EIDL_CONNECTOR_EXPECTED,
7259 d);
7261 so_far_so_good = false;
7262 }
7264 $6->destroy ();
7265 delete $6;
7266 $6 = 0;
7267 }
7269 if (so_far_so_good)
7270 {
7271 AST_Connector *c =
7272 idl_global->gen ()->create_connector (&sn,
7273 parent);
7275 (void) s->fe_add_connector (c);
7277 // Push it on the scopes stack.
7278 idl_global->scopes ().push (c);
7279 }
7281 delete $3;
7282 }
7283 ;
7285 connector_body
7286 : '{'
7287 {
7288 idl_global->set_parse_state (IDL_GlobalData::PS_ConnectorSqSeen);
7289 }
7290 connector_exports
7291 {
7292 idl_global->set_parse_state (IDL_GlobalData::PS_ConnectorBodySeen);
7293 }
7294 '}'
7295 {
7296 idl_global->set_parse_state (IDL_GlobalData::PS_ConnectorQsSeen);
7298 // Done with this connector - pop it off the scope stack.
7299 idl_global->scopes ().pop ();
7300 }
7301 ;
7303 connector_exports
7304 : connector_exports connector_export
7305 | %empty
7306 ;
7308 connector_export
7309 : provides_decl
7310 {
7311 idl_global->set_parse_state (IDL_GlobalData::PS_ProvidesDeclSeen);
7312 }
7313 ';'
7314 {
7315 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
7316 }
7317 | uses_decl
7318 {
7319 idl_global->set_parse_state (IDL_GlobalData::PS_UsesDeclSeen);
7320 }
7321 ';'
7322 {
7323 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
7324 }
7325 | attribute
7326 {
7327 idl_global->set_parse_state (IDL_GlobalData::PS_AttrDeclSeen);
7328 }
7329 ';'
7330 {
7331 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
7332 }
7333 | extended_port_decl
7334 {
7335 idl_global->set_parse_state (IDL_GlobalData::PS_ExtendedPortDeclSeen);
7336 }
7337 ';'
7338 {
7339 idl_global->set_parse_state (IDL_GlobalData::PS_NoState);
7340 }
7341 ;
7343 %%
7344 /* programs */
7346 /*
7347 * ???
7348 */
7349 int
7350 tao_yywrap (void)
7351 {
7352 return 1;
7353 }
7355 /*
7356 * Report an error situation discovered in a production
7357 */
7358 void
7359 tao_yyerror (const char *msg)
7360 {
7361 ACE_ERROR ((LM_ERROR, "%C\n", msg));
7362 }